code-muse 0.0.1__py3-none-any.whl

code_muse/plugins/mindpack/register_callbacks.py

@@ -0,0 +1,175 @@
+"""Callback registration for the MindPack plugin.
+
+Registers:
+- The 'register_tools' hook to expose the ask_mindpack tool to agents.
+- The 'custom_command' + 'custom_command_help' hooks to expose the
+  /ask_mindpack slash command for direct user invocation.
+"""
+
+import logging
+from typing import Any
+
+from code_muse.callbacks import register_callback
+from code_muse.messaging import emit_info, emit_success, emit_warning
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Agent tool registration (existing)
+# ---------------------------------------------------------------------------
+
+
+def _register_mindpack_tools() -> list[dict[str, Any]]:
+    """Callback for the 'register_tools' hook.
+
+    Returns tool definitions that the core tool loader will merge
+    into TOOL_REGISTRY.
+    """
+    from code_muse.plugins.mindpack.tools import register_ask_mindpack
+
+    return [
+        {"name": "ask_mindpack", "register_func": register_ask_mindpack},
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Slash-command help
+# ---------------------------------------------------------------------------
+
+
+def _custom_help() -> list[tuple[str, str]]:
+    """Provide help entries for /help display."""
+    return [
+        (
+            "ask_mindpack",
+            "Run MindPack multi-expert advisory analysis on a problem",
+        ),
+        (
+            "mindpack",
+            "Manage MindPack profiles and expert panel (profiles bundle experts for different tasks)",
+        ),
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Slash-command handler
+# ---------------------------------------------------------------------------
+
+
+async def _handle_custom_command(command: str, name: str) -> bool | None:
+    """Handle the /ask_mindpack slash command.
+
+    Extracts the user's problem description from the command text,
+    spins up the MindPack expert panel, and displays the merged
+    advisory output directly in the chat.
+
+    Returns:
+        True if the command was handled (advisory displayed).
+        None if the command name doesn't match.
+    """
+    if name == "mindpack":
+        from code_muse.plugins.mindpack.mindpack_menu import (
+            interactive_mindpack_menu,
+            interactive_profile_selector_menu,
+        )
+
+        # Profile selector first, then filtered expert menu
+        while True:
+            result = await interactive_profile_selector_menu()
+            if result is None:
+                break  # User exited profile selector
+            if result is True:
+                break  # Profile activated — exit to CLI
+            # Otherwise it's a profile name — open expert list
+            await interactive_mindpack_menu(profile_name=result)
+        return True
+
+    if name != "ask_mindpack":
+        return None
+
+    # Extract problem text after the command name
+    parts = command.split(maxsplit=1)
+    problem_text = parts[1].strip() if len(parts) > 1 else ""
+
+    if not problem_text:
+        emit_warning(
+            "Usage: /ask_mindpack <your problem description>\n"
+            "Example: /ask_mindpack How should I refactor the auth module "
+            "to support multi-tenancy?"
+        )
+        return True
+
+    from code_muse.plugins.mindpack.schemas import AskMindPackInput
+    from code_muse.plugins.mindpack.tools import orchestrator
+
+    emit_info("🧠 MindPack is consulting the expert panel…")
+
+    active_profile = orchestrator.get_active_profile_name()
+    if active_profile:
+        emit_info(f"📋 Active profile: {active_profile}")
+
+    request = AskMindPackInput(
+        problem_statement=problem_text,
+        current_goal="User requested advisory analysis via /ask_mindpack",
+        desired_output="plan",
+    )
+
+    try:
+        output = await orchestrator.consult(request)
+    except Exception as exc:
+        emit_warning(f"MindPack consultation failed: {exc}")
+        return True
+
+    # -- Display results ------------------------------------------------
+    emit_success(f"🧠 MindPack Advisory Complete (confidence: {output.confidence:.2f})")
+
+    emit_info(f"📋 Summary: {output.summary}")
+    emit_info(f"🎯 Recommended Plan:\n{output.recommended_plan}")
+
+    if output.ranked_options:
+        emit_info("🏆 Ranked Options:")
+        for opt in output.ranked_options:
+            emit_info(
+                f"  #{opt.rank} {opt.title} "
+                f"[risk: {opt.risk}, confidence: {opt.confidence:.2f}]"
+            )
+            emit_info(f"    {opt.summary}")
+            if opt.pros:
+                emit_info(f"    Pros: {', '.join(opt.pros)}")
+            if opt.cons:
+                emit_info(f"    Cons: {', '.join(opt.cons)}")
+
+    if output.risks:
+        emit_warning("⚠️ Risks Identified:")
+        for r in output.risks:
+            emit_warning(f"  • {r}")
+
+    if output.tests_to_run:
+        emit_info("🧪 Suggested Tests:")
+        for t in output.tests_to_run:
+            emit_info(f"  • {t}")
+
+    if output.files_to_inspect_or_change:
+        emit_info("📁 Files to Inspect/Change:")
+        for f in output.files_to_inspect_or_change:
+            emit_info(f"  • {f}")
+
+    if output.disagreements:
+        emit_warning("⚡ Expert Disagreements:")
+        for d in output.disagreements:
+            emit_warning(f"  • {d}")
+
+    emit_info(f"🤝 Expert Consensus: {output.expert_consensus}")
+
+    return True  # Handled — no model invocation needed
+
+
+# ---------------------------------------------------------------------------
+# Register all callbacks
+# ---------------------------------------------------------------------------
+
+register_callback("register_tools", _register_mindpack_tools)
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)
+
+logger.debug("MindPack plugin callbacks registered")

code_muse/plugins/mindpack/schemas.py

@@ -0,0 +1,358 @@
+"""MindPack schemas — shared Pydantic models for cross-module use.
+
+Breaks the circular dependency between ``orchestration.py`` and ``tools.py``
+by keeping pure data models in a single importable location.
+
+These models carry no logic — they are plain data contracts.
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+# ---------------------------------------------------------------------------
+# Expert descriptor
+# ---------------------------------------------------------------------------
+
+
+class ExpertDescriptor(BaseModel):
+    """Metadata describing an expert that may be consulted."""
+
+    name: str = Field(..., description="Unique expert identifier")
+    speciality: str = Field(..., description="Domain of expertise")
+    system_prompt_fragment: str = Field(
+        default="",
+        description="Prompt fragment injected into the expert's context",
+    )
+    max_experts_override: int | None = Field(
+        default=None,
+        description="If set, caps how many experts of this type to spawn",
+    )
+    model: str | None = Field(
+        default=None,
+        description="Optional custom model override for this specific expert",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Profile descriptor
+# ---------------------------------------------------------------------------
+
+
+class ProfileDescriptor(BaseModel):
+    """A named bundle of expert names forming a reusable advisory panel."""
+
+    name: str = Field(..., description="Unique profile identifier")
+    description: str = Field(
+        default="",
+        description="Human-readable summary of what this profile is for",
+    )
+    expert_names: list[str] = Field(
+        default_factory=list,
+        description="Names of experts that belong to this profile",
+    )
+
+
+# ---------------------------------------------------------------------------
+# AskMindPack I/O models
+# ---------------------------------------------------------------------------
+
+
+class MindPackRankedOption(BaseModel):
+    """A single ranked option produced by the MindPack judge."""
+
+    rank: int = Field(..., description="Ranking position (1 = best)")
+    title: str = Field(..., description="Short title for this option")
+    source_experts: list[str] = Field(
+        default_factory=list,
+        description="Expert names that contributed to this option",
+    )
+    summary: str = Field(..., description="One-paragraph summary of the option")
+    pros: list[str] = Field(default_factory=list, description="Advantages")
+    cons: list[str] = Field(default_factory=list, description="Disadvantages")
+    risk: Literal["low", "medium", "high"] = Field(
+        default="medium", description="Risk level"
+    )
+    confidence: float = Field(
+        default=0.5, ge=0, le=1, description="Confidence score 0–1"
+    )
+
+
+class MindPackComparisonMatrix(BaseModel):
+    consensus_points: list[str] = Field(default_factory=list)
+    disagreements: list[str] = Field(default_factory=list)
+    unsupported_claims: list[str] = Field(default_factory=list)
+    missing_information: list[str] = Field(default_factory=list)
+    ranked_options: list[MindPackRankedOption] = Field(default_factory=list)
+
+
+class MindPackMergedDecision(BaseModel):
+    summary: str
+    comparison: MindPackComparisonMatrix
+    selected_option: MindPackRankedOption
+    merged_plan_steps: list[str] = Field(default_factory=list)
+    files_to_inspect_first: list[str] = Field(default_factory=list)
+    files_expected_to_change: list[str] = Field(default_factory=list)
+    tests_to_run: list[str] = Field(default_factory=list)
+    risks: list[str] = Field(default_factory=list)
+    acceptance_criteria: list[str] = Field(default_factory=list)
+    executor_instructions: str
+    confidence: float = Field(default=0.5, ge=0, le=1)
+
+
+class AskMindPackInput(BaseModel):
+    """Input model for the ask_mindpack tool.
+
+    Carries the executor's problem context so MindPack can spin up
+    an appropriate expert pool.
+    """
+
+    problem_statement: str = Field(..., description="The specific problem to solve")
+    current_goal: str = Field(
+        ..., description="What the executor is currently trying to achieve"
+    )
+    current_plan: str | None = Field(default=None, description="Current plan, if any")
+    what_has_been_tried: list[str] = Field(
+        default_factory=list,
+        description="Approaches already attempted",
+    )
+    relevant_files: list[str] = Field(
+        default_factory=list,
+        description="File paths relevant to the problem",
+    )
+    observed_errors: list[str] = Field(
+        default_factory=list,
+        description="Error messages or unexpected behaviours observed",
+    )
+    uncertainty: str | None = Field(
+        default=None,
+        description="What the executor is uncertain about",
+    )
+    desired_output: Literal[
+        "plan",
+        "review",
+        "debug_strategy",
+        "architecture_decision",
+        "test_strategy",
+        "compare_options",
+    ] = Field(
+        default="plan",
+        description="Kind of advisory output the executor wants",
+    )
+    max_experts: int | None = Field(
+        default=None,
+        description="Cap on number of experts to consult",
+    )
+
+
+class AskMindPackOutput(BaseModel):
+    """Output model for the ask_mindpack tool.
+
+    Returns a merged, judge-vetted advisory response that the
+    executor can use to continue its work.
+    """
+
+    summary: str = Field(..., description="High-level summary of the advisory")
+    recommended_plan: str = Field(..., description="The judge-merged recommended plan")
+    ranked_options: list[MindPackRankedOption] = Field(
+        default_factory=list,
+        description="Ranked alternative options from the expert pool",
+    )
+    risks: list[str] = Field(
+        default_factory=list,
+        description="Risks identified across all experts",
+    )
+    tests_to_run: list[str] = Field(
+        default_factory=list,
+        description="Suggested tests to validate the plan",
+    )
+    files_to_inspect_or_change: list[str] = Field(
+        default_factory=list,
+        description="Files the experts recommend inspecting or changing",
+    )
+    expert_consensus: str = Field(..., description="Summary of what experts agreed on")
+    disagreements: list[str] = Field(
+        default_factory=list,
+        description="Key disagreements between experts",
+    )
+    confidence: float = Field(
+        default=0.5,
+        ge=0,
+        le=1,
+        description="Overall confidence in the recommendation",
+    )
+
+
+# ---------------------------------------------------------------------------
+# MindPack V3 Configuration & Expert Models
+# ---------------------------------------------------------------------------
+
+
+ExpertSpawnMode = Literal[
+    "fixed",
+    "adaptive",
+    "same_agent_replicas",
+    "multi_model_replicas",
+    "multi_agent",
+    "hybrid",
+]
+
+ModelStrategy = Literal[
+    "same_model",
+    "model_pool",
+    "per_expert",
+]
+
+ReportStoreMode = Literal[
+    "memory",
+    "cache",
+    "workspace",
+    "both",
+]
+
+MemoryScope = Literal[
+    "run",
+    "session",
+    "project",
+]
+
+
+class MindPackExpertSpec(BaseModel):
+    id: str
+    agent: str | None = None
+    model: str | None = None
+    lens: str
+    prompt_variant: str
+    permissions: Literal["read_only"] = "read_only"
+    max_model_requests: int = Field(default=8, ge=1, le=20)
+    max_tool_calls: int = Field(default=20, ge=0, le=100)
+
+
+class MindPackJudgeSpec(BaseModel):
+    id: str = "judge"
+    agent: str | None = None
+    model: str | None = None
+    lens: str = "compare_merge_rank"
+    permissions: Literal["read_only"] = "read_only"
+    max_model_requests: int = Field(default=6, ge=1, le=20)
+    max_tool_calls: int = Field(default=10, ge=0, le=100)
+
+
+class MindPackExpertPoolConfig(BaseModel):
+    spawn_mode: ExpertSpawnMode = "fixed"
+    default_expert_count: int = Field(default=5, ge=1, le=12)
+    min_experts: int = Field(default=3, ge=1, le=12)
+    max_experts: int = Field(default=7, ge=1, le=12)
+    model_strategy: ModelStrategy = "same_model"
+    experts: list[MindPackExpertSpec] = Field(default_factory=list)
+    judge: MindPackJudgeSpec = Field(default_factory=MindPackJudgeSpec)
+
+
+class MindPackReportStoreConfig(BaseModel):
+    mode: ReportStoreMode = "memory"
+    memory_scope: MemoryScope = "run"
+    workspace_dir: str = ".mindpack/runs"
+    cache_dir: str = "~/.muse/packmind/runs"
+    save_raw_transcripts: bool = False
+
+
+class MindPackNestedConfig(BaseModel):
+    enabled: bool = True
+    mode: Literal["advisory", "review", "debug"] = "advisory"
+    max_depth: int = Field(default=1, ge=0, le=2)
+    max_calls_per_prompt: int = Field(default=2, ge=0, le=10)
+    timeout_sec: int = Field(default=90, ge=10, le=600)
+
+
+class MindPackConfig(BaseModel):
+    """Unified root configuration for MindPack V3.
+
+    Wraps the three sub-config domains — expert pool, report storage,
+    and nested (ask_mindpack) behaviour — into a single config object.
+    """
+
+    expert_pool: MindPackExpertPoolConfig = Field(
+        default_factory=MindPackExpertPoolConfig,
+        description="Expert pool spawning and model strategy settings",
+    )
+    report_store: MindPackReportStoreConfig = Field(
+        default_factory=MindPackReportStoreConfig,
+        description="Report storage mode and paths",
+    )
+    nested: MindPackNestedConfig = Field(
+        default_factory=MindPackNestedConfig,
+        description="Nested ask_mindpack workflow limits",
+    )
+
+
+DEFAULT_MINDPACK_CONFIG = MindPackConfig()
+
+
+class MindPackExpertReport(BaseModel):
+    run_id: str
+    expert_id: str
+    agent: str | None = None
+    model: str | None = None
+    lens: str
+    prompt_variant: str
+    status: Literal["success", "partial", "failed", "timeout"] = "success"
+    summary: str
+    findings: list[str] = Field(default_factory=list)
+    proposed_plan: list[str] = Field(default_factory=list)
+    files_to_inspect: list[str] = Field(default_factory=list)
+    files_expected_to_change: list[str] = Field(default_factory=list)
+    risks: list[str] = Field(default_factory=list)
+    tests_to_run: list[str] = Field(default_factory=list)
+    assumptions: list[str] = Field(default_factory=list)
+    confidence: float = Field(default=0.5, ge=0, le=1)
+
+
+# ---------------------------------------------------------------------------
+# Default profiles
+# ---------------------------------------------------------------------------
+
+_DEFAULT_PROFILES: list[ProfileDescriptor] = [
+    ProfileDescriptor(
+        name="Full Panel",
+        description="All five default experts — full coverage",
+        expert_names=[
+            "Scout",
+            "Architect",
+            "Strategic Architect",
+            "Systems Architect",
+            "Pragmatic Architect",
+            "Watchdog",
+            "Test Planner",
+            "Challenger",
+        ],
+    ),
+    ProfileDescriptor(
+        name="Security Audit",
+        description="Focused on risk, security, and adversarial review",
+        expert_names=["Watchdog", "Challenger"],
+    ),
+    ProfileDescriptor(
+        name="Code Review",
+        description="Design and testing focus for code review",
+        expert_names=["Architect", "Test Planner"],
+    ),
+    ProfileDescriptor(
+        name="Performance",
+        description="Lean panel for quick performance analysis",
+        expert_names=["Scout", "Watchdog"],
+    ),
+    ProfileDescriptor(
+        name="Planning",
+        description="Three architect perspectives — strategic, systems, and pragmatic — competing to produce the best plan",
+        expert_names=[
+            "Strategic Architect",
+            "Systems Architect",
+            "Pragmatic Architect",
+        ],
+    ),
+    ProfileDescriptor(
+        name="Default",
+        description="Catch-all for experts not in any other profile",
+        expert_names=[],
+    ),
+]