/brainstorm

/brainstorm [topic or challenge]

# Architecture brainstorming
/brainstorm "How should we architect multi-tenant data isolation in Prismatic Storage?"

# Performance optimization ideation
/brainstorm "Our LiveView dashboard is slow with 1000+ concurrent users"

# Feature design facilitation
/brainstorm "Ideas for making Prismatic Storage more accessible to non-technical users"

# Security architecture exploration
/brainstorm "Design an epistemic security layer that detects knowledge manipulation"

# Integration design
/brainstorm "Best approaches for integrating KuzuDB graph database with existing ETS storage"

defmodule Prismatic.Commands.Brainstorm do
  @moduledoc """
  Intelligent brainstorming with agent-based query refinement
  and multi-agent creative ideation.
  """

  @spec execute(topic :: String.t(), opts :: keyword()) ::
          {:ok, BrainstormReport.t()} | {:error, term()}
  def execute(topic, opts \\ []) do
    with {:ok, query_analysis} <- analyze_query(topic),
         {:ok, agents} <- discover_and_select_agents(query_analysis),
         {:ok, refined} <- refine_requirements(topic, agents),
         {:ok, validated} <- interactive_validation(refined, agents),
         {:ok, ideation} <- execute_multi_agent_brainstorm(validated, agents),
         {:ok, report} <- generate_brainstorm_report(ideation) do
      {:ok, report}
    end
  end

  defp discover_and_select_agents(query_analysis) do
    registry = load_agent_registry()

    lead = determine_lead_agent(registry, query_analysis)
    support = rank_and_select_support(registry, query_analysis, max_agents: 5)

    {:ok, %{lead: lead, support: support}}
  end

  defp refine_requirements(topic, agents) do
    explicit = extract_explicit_requirements(topic)
    implicit = infer_implicit_requirements(topic)

    perspectives = Enum.map([agents.lead | agents.support], fn agent ->
      agent.analyze_requirements(%{explicit: explicit, implicit: implicit})
    end)

    {:ok, %{
      expanded: merge_and_expand(perspectives),
      questions: generate_clarification_questions(perspectives),
      assumptions: surface_assumptions(perspectives),
      alternatives: suggest_alternative_framings(perspectives)
    }}
  end
end

Related Commands