foundry-mcp 0.3.3__py3-none-any.whl → 0.8.10__py3-none-any.whl

foundry_mcp/__init__.py

@@ -1,6 +1,12 @@
 """Foundry MCP - MCP server for SDD toolkit spec management."""
 
-__version__ = "0.1.0"
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("foundry-mcp")
+except PackageNotFoundError:
+    # Package not installed (development mode without editable install)
+    __version__ = "0.7.0"
 
 from foundry_mcp.server import create_server, main
 

foundry_mcp/cli/__init__.py

@@ -5,13 +5,6 @@ All commands emit structured JSON to stdout for reliable parsing.
 """
 
 from foundry_mcp.cli.config import CLIContext, create_context
-from foundry_mcp.cli.flags import (
-    CLIFlagRegistry,
-    apply_cli_flag_overrides,
-    flags_for_discovery,
-    get_cli_flags,
-    with_flag_options,
-)
 from foundry_mcp.cli.logging import (
     CLILogContext,
     cli_command,
@@ -51,12 +44,6 @@ __all__ = [
     "emit",
     "emit_error",
     "emit_success",
-    # Feature flags
-    "CLIFlagRegistry",
-    "apply_cli_flag_overrides",
-    "flags_for_discovery",
-    "get_cli_flags",
-    "with_flag_options",
     # Logging
     "CLILogContext",
     "cli_command",

foundry_mcp/cli/commands/plan.py

@@ -20,6 +20,7 @@ from foundry_mcp.cli.resilience import (
     handle_keyboard_interrupt,
 )
 from foundry_mcp.core.spec import find_specs_directory
+from foundry_mcp.core.llm_config import get_consultation_config
 
 logger = get_cli_logger()
 
@@ -135,8 +136,8 @@ def plan_group() -> None:
     "--type",
     "review_type",
     type=click.Choice(REVIEW_TYPES),
-    default="full",
-    help="Type of review to perform.",
+    default=None,
+    help="Type of review to perform (defaults to config value, typically 'full').",
 )
 @click.option(
     "--ai-provider",
@@ -165,7 +166,7 @@ def plan_group() -> None:
 def plan_review_cmd(
     ctx: click.Context,
     plan_path: str,
-    review_type: str,
+    review_type: Optional[str],
     ai_provider: Optional[str],
     ai_timeout: float,
     no_consultation_cache: bool,
@@ -184,6 +185,12 @@ def plan_review_cmd(
 
         sdd plan review ./PLAN.md --ai-provider gemini
     """
+    # Get default review_type from config if not provided
+    if review_type is None:
+        consultation_config = get_consultation_config()
+        workflow_config = consultation_config.get_workflow_config("markdown_plan_review")
+        review_type = workflow_config.default_review_type
+
     start_time = time.perf_counter()
 
     llm_status = _get_llm_status()

foundry_mcp/cli/commands/review.py

@@ -16,6 +16,7 @@ AI-enhanced reviews use:
 
 import json
 import time
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import click
@@ -42,6 +43,7 @@ from foundry_mcp.tools.unified.review_helpers import (
     _run_ai_review,
     _run_quick_review,
 )
+from foundry_mcp.core.llm_config import get_consultation_config
 
 logger = get_cli_logger()
 
@@ -121,8 +123,8 @@ def review_group() -> None:
     "--type",
     "review_type",
     type=click.Choice(REVIEW_TYPES),
-    default="quick",
-    help="Type of review to perform.",
+    default=None,
+    help="Type of review to perform (defaults to config value, typically 'full').",
 )
 @click.option(
     "--tools",
@@ -159,7 +161,7 @@ def review_group() -> None:
 def review_spec_cmd(
     ctx: click.Context,
     spec_id: str,
-    review_type: str,
+    review_type: Optional[str],
     tools: Optional[str],
     model: Optional[str],
     ai_provider: Optional[str],
@@ -172,6 +174,12 @@ def review_spec_cmd(
     cli_ctx = get_context(ctx)
     specs_dir = cli_ctx.specs_dir
 
+    # Get default review_type from config if not provided
+    if review_type is None:
+        consultation_config = get_consultation_config()
+        workflow_config = consultation_config.get_workflow_config("plan_review")
+        review_type = workflow_config.default_review_type
+
     if specs_dir is None:
         emit_error(
             "No specs directory found",
@@ -538,8 +546,15 @@ def _run_fidelity_review(
     spec_requirements = _build_spec_requirements(spec_data, task_id, phase_id)
 
     # Build implementation artifacts (file contents, git diff if incremental)
+    workspace_root = Path(specs_dir).parent if specs_dir else None
     implementation_artifacts = _build_implementation_artifacts(
-        spec_data, task_id, phase_id, files, incremental, base_branch
+        spec_data,
+        task_id,
+        phase_id,
+        files,
+        incremental,
+        base_branch,
+        workspace_root=workspace_root,
     )
 
     # Build test results section

foundry_mcp/cli/commands/session.py

@@ -183,12 +183,11 @@ def show_limits_cmd(ctx: click.Context) -> None:
 @handle_keyboard_interrupt()
 @with_sync_timeout(FAST_TIMEOUT, "Capabilities lookup timed out")
 def session_capabilities_cmd(ctx: click.Context) -> None:
-    """Show CLI capabilities and feature flags.
+    """Show CLI capabilities.
 
     Returns a manifest of available features, commands, and their status
     for AI coding assistants to understand available functionality.
     """
-    from foundry_mcp.cli.flags import flags_for_discovery, get_cli_flags
     from foundry_mcp.cli.main import cli
 
     cli_ctx = get_context(ctx)
@@ -204,15 +203,10 @@ def session_capabilities_cmd(ctx: click.Context) -> None:
         else:
             command_groups[name] = {"type": "command"}
 
-    # Get feature flags
-    get_cli_flags()
-    flags = flags_for_discovery()
-
     # Known CLI capabilities
     capabilities = {
         "json_output": True,  # All output is JSON
         "spec_driven": True,  # SDD methodology supported
-        "feature_flags": True,  # Feature flag system available
         "session_tracking": True,  # Session/context tracking
         "rate_limiting": True,  # Rate limiting built-in
     }
@@ -222,7 +216,6 @@ def session_capabilities_cmd(ctx: click.Context) -> None:
             "version": "0.1.0",
             "name": "foundry-cli",
             "capabilities": capabilities,
-            "feature_flags": flags,
             "command_groups": list(command_groups.keys()),
             "command_count": len(cli.commands),
             "specs_dir": str(cli_ctx.specs_dir) if cli_ctx.specs_dir else None,

foundry_mcp/cli/commands/specs.py

@@ -27,7 +27,8 @@ from foundry_mcp.core.spec import list_specs as core_list_specs, load_spec
 logger = get_cli_logger()
 
 # Valid templates and categories
-TEMPLATES = ("simple", "medium", "complex", "security")
+# Note: Only 'empty' template is supported. Use phase templates to add structure.
+TEMPLATES = ("empty",)
 CATEGORIES = ("investigation", "implementation", "refactoring", "decision", "research")
 
 
@@ -51,20 +52,31 @@ def generate_spec_id(name: str) -> str:
 def get_template_structure(template: str, category: str) -> Dict[str, Any]:
     """Get the hierarchical structure for a spec template.
 
+    Only 'empty' template is supported. Use phase templates to add structure.
+
     Args:
-        template: Template type (simple, medium, complex, security).
+        template: Template type (only 'empty' is valid).
         category: Default task category.
 
     Returns:
         Hierarchy dict for the spec.
+
+    Raises:
+        ValueError: If template is not 'empty'.
     """
-    base_hierarchy = {
+    if template != "empty":
+        raise ValueError(
+            f"Invalid template '{template}'. Only 'empty' template is supported. "
+            f"Use phase templates to add structure."
+        )
+
+    return {
         "spec-root": {
             "type": "spec",
             "title": "",  # Filled in later
             "status": "pending",
             "parent": None,
-            "children": ["phase-1"],
+            "children": [],
             "total_tasks": 0,
             "completed_tasks": 0,
             "metadata": {
@@ -77,180 +89,8 @@ def get_template_structure(template: str, category: str) -> Dict[str, Any]:
                 "depends": [],
             },
         },
-        "phase-1": {
-            "type": "phase",
-            "title": "Planning & Discovery",
-            "status": "pending",
-            "parent": "spec-root",
-            "children": ["task-1-1"],
-            "total_tasks": 1,
-            "completed_tasks": 0,
-            "metadata": {
-                "purpose": "Initial planning and requirements gathering",
-                "estimated_hours": 2,
-            },
-            "dependencies": {
-                "blocks": [],
-                "blocked_by": [],
-                "depends": [],
-            },
-        },
-        "task-1-1": {
-            "type": "task",
-            "title": "Define requirements",
-            "status": "pending",
-            "parent": "phase-1",
-            "children": [],
-            "total_tasks": 1,
-            "completed_tasks": 0,
-            "metadata": {
-                "details": "Document the requirements and acceptance criteria",
-                "category": category,
-                "estimated_hours": 1,
-            },
-            "dependencies": {
-                "blocks": [],
-                "blocked_by": [],
-                "depends": [],
-            },
-        },
     }
 
-    if template == "simple":
-        return base_hierarchy
-
-    # Medium template adds implementation phase
-    if template in ("medium", "complex", "security"):
-        base_hierarchy["spec-root"]["children"].append("phase-2")
-        base_hierarchy["phase-1"]["dependencies"]["blocks"].append("phase-2")
-        base_hierarchy["phase-2"] = {
-            "type": "phase",
-            "title": "Implementation",
-            "status": "pending",
-            "parent": "spec-root",
-            "children": ["task-2-1"],
-            "total_tasks": 1,
-            "completed_tasks": 0,
-            "metadata": {
-                "purpose": "Core implementation work",
-                "estimated_hours": 8,
-            },
-            "dependencies": {
-                "blocks": [],
-                "blocked_by": ["phase-1"],
-                "depends": [],
-            },
-        }
-        base_hierarchy["task-2-1"] = {
-            "type": "task",
-            "title": "Implement core functionality",
-            "status": "pending",
-            "parent": "phase-2",
-            "children": [],
-            "total_tasks": 1,
-            "completed_tasks": 0,
-            "metadata": {
-                "details": "Implement the main features",
-                "category": category,
-                "estimated_hours": 4,
-            },
-            "dependencies": {
-                "blocks": [],
-                "blocked_by": [],
-                "depends": [],
-            },
-        }
-        base_hierarchy["spec-root"]["total_tasks"] = 2
-        base_hierarchy["phase-1"]["total_tasks"] = 1
-
-    # Complex template adds verification phase
-    if template in ("complex", "security"):
-        base_hierarchy["spec-root"]["children"].append("phase-3")
-        base_hierarchy["phase-2"]["dependencies"]["blocks"].append("phase-3")
-        base_hierarchy["phase-3"] = {
-            "type": "phase",
-            "title": "Verification & Testing",
-            "status": "pending",
-            "parent": "spec-root",
-            "children": ["verify-3-1"],
-            "total_tasks": 1,
-            "completed_tasks": 0,
-            "metadata": {
-                "purpose": "Verify implementation meets requirements",
-                "estimated_hours": 4,
-            },
-            "dependencies": {
-                "blocks": [],
-                "blocked_by": ["phase-2"],
-                "depends": [],
-            },
-        }
-        base_hierarchy["verify-3-1"] = {
-            "type": "verify",
-            "title": "Run test suite",
-            "status": "pending",
-            "parent": "phase-3",
-            "children": [],
-            "total_tasks": 1,
-            "completed_tasks": 0,
-            "metadata": {
-                "verification_type": "auto",
-                "command": "pytest",
-                "expected": "All tests pass",
-            },
-            "dependencies": {
-                "blocks": [],
-                "blocked_by": [],
-                "depends": [],
-            },
-        }
-        base_hierarchy["spec-root"]["total_tasks"] = 3
-
-    # Security template adds security review phase
-    if template == "security":
-        base_hierarchy["spec-root"]["children"].append("phase-4")
-        base_hierarchy["phase-3"]["dependencies"]["blocks"].append("phase-4")
-        base_hierarchy["phase-4"] = {
-            "type": "phase",
-            "title": "Security Review",
-            "status": "pending",
-            "parent": "spec-root",
-            "children": ["task-4-1"],
-            "total_tasks": 1,
-            "completed_tasks": 0,
-            "metadata": {
-                "purpose": "Security audit and hardening",
-                "estimated_hours": 4,
-            },
-            "dependencies": {
-                "blocks": [],
-                "blocked_by": ["phase-3"],
-                "depends": [],
-            },
-        }
-        base_hierarchy["task-4-1"] = {
-            "type": "task",
-            "title": "Security audit",
-            "status": "pending",
-            "parent": "phase-4",
-            "children": [],
-            "total_tasks": 1,
-            "completed_tasks": 0,
-            "metadata": {
-                "details": "Review for security vulnerabilities",
-                "category": "investigation",
-                "estimated_hours": 2,
-            },
-            "dependencies": {
-                "blocks": [],
-                "blocked_by": [],
-                "depends": [],
-            },
-        }
-        base_hierarchy["spec-root"]["total_tasks"] = 4
-
-    return base_hierarchy
-
 
 @click.group("specs")
 def specs() -> None:
@@ -260,36 +100,18 @@ def specs() -> None:
 
 # Template definitions for listing/showing
 TEMPLATE_INFO = {
-    "simple": {
-        "name": "simple",
-        "description": "Minimal spec with single planning phase",
-        "phases": 1,
-        "tasks": 1,
-        "use_cases": ["Quick fixes", "Small features", "Simple investigations"],
-    },
-    "medium": {
-        "name": "medium",
-        "description": "Standard spec with planning and implementation phases",
-        "phases": 2,
-        "tasks": 2,
-        "use_cases": ["New features", "Moderate refactoring", "Standard development"],
-    },
-    "complex": {
-        "name": "complex",
-        "description": "Full spec with planning, implementation, and verification phases",
-        "phases": 3,
-        "tasks": 3,
-        "use_cases": ["Large features", "Major refactoring", "Critical systems"],
-    },
-    "security": {
-        "name": "security",
-        "description": "Complete spec with security review phase",
-        "phases": 4,
-        "tasks": 4,
-        "use_cases": ["Security-sensitive features", "Authentication", "Data handling"],
+    "empty": {
+        "name": "empty",
+        "description": "Blank spec with no phases - use phase templates to add structure",
+        "phases": 0,
+        "tasks": 0,
+        "use_cases": ["All specs - add phases via phase-add-bulk or phase-template apply"],
     },
 }
 
+# Phase templates available for adding structure
+PHASE_TEMPLATES = ("planning", "implementation", "testing", "security", "documentation")
+
 
 @specs.command("template")
 @click.argument("action", type=click.Choice(["list", "show"]))
@@ -456,8 +278,8 @@ def analyze(ctx: click.Context, directory: Optional[str] = None) -> None:
 @click.option(
     "--template",
     type=click.Choice(TEMPLATES),
-    default="medium",
-    help="Spec template: simple, medium, complex, or security.",
+    default="empty",
+    help="Spec template (only 'empty' supported - use phase templates to add structure).",
 )
 @click.option(
     "--category",
@@ -465,6 +287,12 @@ def analyze(ctx: click.Context, directory: Optional[str] = None) -> None:
     default="implementation",
     help="Default task category.",
 )
+@click.option(
+    "--mission",
+    type=str,
+    default="",
+    help="Optional mission statement for the spec.",
+)
 @click.pass_context
 @cli_command("create")
 @handle_keyboard_interrupt()
@@ -474,6 +302,7 @@ def create(
     name: str,
     template: str,
     category: str,
+    mission: str,
 ) -> None:
     """Create a new specification.
 
@@ -523,8 +352,9 @@ def create(
         "last_updated": now,
         "metadata": {
             "description": "",
+            "mission": mission.strip(),
             "objectives": [],
-            "complexity": "medium" if template in ("medium", "complex") else "low",
+            "complexity": "low",  # Set explicitly via metadata, not template
             "estimated_hours": sum(
                 node.get("metadata", {}).get("estimated_hours", 0)
                 for node in hierarchy.values()
@@ -534,13 +364,13 @@ def create(
             "status": "pending",
             "owner": "",
             "progress_percentage": 0,
-            "current_phase": "phase-1",
+            "current_phase": None,  # Empty template has no phases
             "category": category,
             "template": template,
         },
         "progress_percentage": 0,
         "status": "pending",
-        "current_phase": "phase-1",
+        "current_phase": None,  # Empty template has no phases
         "hierarchy": hierarchy,
         "journal": [],
     }

foundry_mcp/cli/context.py

@@ -29,6 +29,43 @@ class SessionStats:
     last_activity: Optional[str] = None
 
 
+@dataclass
+class AutonomousSession:
+    """
+    Ephemeral state for autonomous task execution mode.
+
+    This tracks whether the agent is running in autonomous mode where
+    it continues to the next task without explicit user confirmation.
+
+    NOTE: This state is EPHEMERAL - it exists only in memory and does
+    not persist across CLI restarts. Each new CLI session starts with
+    autonomous mode disabled.
+    """
+    enabled: bool = False
+    tasks_completed: int = 0
+    pause_reason: Optional[str] = None  # Why auto-mode paused: "limit", "error", "user", "context"
+    started_at: Optional[str] = None    # ISO timestamp when auto-mode was enabled
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON output."""
+        return {
+            "enabled": self.enabled,
+            "tasks_completed": self.tasks_completed,
+            "pause_reason": self.pause_reason,
+            "started_at": self.started_at,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AutonomousSession":
+        """Create from dictionary (for in-session use only)."""
+        return cls(
+            enabled=data.get("enabled", False),
+            tasks_completed=data.get("tasks_completed", 0),
+            pause_reason=data.get("pause_reason"),
+            started_at=data.get("started_at"),
+        )
+
+
 @dataclass
 class ContextSession:
     """
@@ -44,6 +81,7 @@ class ContextSession:
     limits: SessionLimits = field(default_factory=SessionLimits)
     stats: SessionStats = field(default_factory=SessionStats)
     metadata: Dict[str, Any] = field(default_factory=dict)
+    autonomous: Optional[AutonomousSession] = None
 
     @property
     def consultations_remaining(self) -> int:
@@ -111,6 +149,7 @@ class ContextSession:
                 "at_limit": self.at_limit,
             },
             "metadata": self.metadata,
+            "autonomous": self.autonomous.to_dict() if self.autonomous else None,
         }
 
 

foundry_mcp/cli/output.py

@@ -35,12 +35,12 @@ def emit(data: Any) -> None:
     """Emit JSON to stdout.
 
     This is the single output function for all CLI commands.
-    Data is serialized with indent=2 for readability when debugging.
+    Data is serialized in minified format for smaller payloads.
 
     Args:
         data: Any JSON-serializable data structure.
     """
-    print(json.dumps(data, indent=2, default=str))
+    print(json.dumps(data, separators=(",", ":"), default=str))
 
 
 def emit_error(
@@ -75,7 +75,7 @@ def emit_error(
         details=details,
         request_id=_ensure_request_id(),
     )
-    print(json.dumps(asdict(response), indent=2, default=str), file=sys.stderr)
+    print(json.dumps(asdict(response), separators=(",", ":"), default=str), file=sys.stderr)
     sys.exit(1)