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

foundry_mcp/config.py

@@ -10,6 +10,7 @@ Environment variables:
 - FOUNDRY_MCP_WORKSPACE_ROOTS: Comma-separated list of workspace root paths
 - FOUNDRY_MCP_SPECS_DIR: Path to specs directory
 - FOUNDRY_MCP_JOURNALS_PATH: Path to journals directory
+- FOUNDRY_MCP_BIKELANE_DIR: Path to bikelane intake queue directory (default: specs/.bikelane)
 - FOUNDRY_MCP_LOG_LEVEL: Logging level (DEBUG, INFO, WARNING, ERROR)
 - FOUNDRY_MCP_API_KEYS: Comma-separated list of valid API keys (optional)
 - FOUNDRY_MCP_REQUIRE_AUTH: Whether to require API key authentication (true/false)
@@ -27,6 +28,7 @@ import logging
 import functools
 import time
 from dataclasses import dataclass, field
+from importlib.metadata import version as get_package_version, PackageNotFoundError
 from pathlib import Path
 from typing import Optional, List, Dict, Any, Callable, TypeVar
 
@@ -38,6 +40,17 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
+
+def _get_version() -> str:
+    """Get package version from metadata (single source of truth: pyproject.toml)."""
+    try:
+        return get_package_version("foundry-mcp")
+    except PackageNotFoundError:
+        return "0.5.0"  # Fallback for dev without install
+
+
+_PACKAGE_VERSION = _get_version()
+
 T = TypeVar("T")
 
 
@@ -149,7 +162,7 @@ class ErrorCollectionConfig:
 
     Attributes:
         enabled: Whether error collection is enabled
-        storage_path: Directory path for error storage (default: .cache/foundry-mcp/errors)
+        storage_path: Directory path for error storage (default: ~/.foundry-mcp/errors)
         retention_days: Delete records older than this many days
         max_errors: Maximum number of error records to keep
         include_stack_traces: Whether to include stack traces in error records
@@ -190,7 +203,7 @@ class ErrorCollectionConfig:
         """
         if self.storage_path:
             return Path(self.storage_path).expanduser()
-        return Path.home() / ".cache" / "foundry-mcp" / "errors"
+        return Path.home() / ".foundry-mcp" / "errors"
 
 
 @dataclass
@@ -203,7 +216,7 @@ class MetricsPersistenceConfig:
 
     Attributes:
         enabled: Whether metrics persistence is enabled
-        storage_path: Directory path for metrics storage (default: .cache/foundry-mcp/metrics)
+        storage_path: Directory path for metrics storage (default: ~/.foundry-mcp/metrics)
         retention_days: Delete records older than this many days
         max_records: Maximum number of metric data points to keep
         bucket_interval_seconds: Aggregation bucket interval (default: 60s = 1 minute)
@@ -262,7 +275,7 @@ class MetricsPersistenceConfig:
         """
         if self.storage_path:
             return Path(self.storage_path).expanduser()
-        return Path.home() / ".cache" / "foundry-mcp" / "metrics"
+        return Path.home() / ".foundry-mcp" / "metrics"
 
     def should_persist_metric(self, metric_name: str) -> bool:
         """Check if a metric should be persisted.
@@ -319,6 +332,180 @@ class DashboardConfig:
         )
 
 
+@dataclass
+class RunnerConfig:
+    """Configuration for a test runner (pytest, go, npm, etc.).
+
+    Attributes:
+        command: Command to execute (e.g., ["go", "test"] or ["python", "-m", "pytest"])
+        run_args: Additional arguments for running tests
+        discover_args: Arguments for test discovery
+        pattern: File pattern for test discovery (e.g., "*_test.go", "test_*.py")
+        timeout: Default timeout in seconds
+    """
+
+    command: List[str] = field(default_factory=list)
+    run_args: List[str] = field(default_factory=list)
+    discover_args: List[str] = field(default_factory=list)
+    pattern: str = "*"
+    timeout: int = 300
+
+    @classmethod
+    def from_toml_dict(cls, data: Dict[str, Any]) -> "RunnerConfig":
+        """Create config from TOML dict.
+
+        Args:
+            data: Dict from TOML parsing
+
+        Returns:
+            RunnerConfig instance
+        """
+        command = data.get("command", [])
+        # Handle string command (convert to list)
+        if isinstance(command, str):
+            command = command.split()
+
+        run_args = data.get("run_args", [])
+        if isinstance(run_args, str):
+            run_args = run_args.split()
+
+        discover_args = data.get("discover_args", [])
+        if isinstance(discover_args, str):
+            discover_args = discover_args.split()
+
+        return cls(
+            command=command,
+            run_args=run_args,
+            discover_args=discover_args,
+            pattern=str(data.get("pattern", "*")),
+            timeout=int(data.get("timeout", 300)),
+        )
+
+
+@dataclass
+class TestConfig:
+    """Configuration for test runners.
+
+    Supports multiple test runners (pytest, go, npm, etc.) with configurable
+    commands and arguments. Runners can be defined in TOML config and selected
+    at runtime via the 'runner' parameter.
+
+    Attributes:
+        default_runner: Default runner to use when none specified
+        runners: Dict of runner name to RunnerConfig
+    """
+
+    default_runner: str = "pytest"
+    runners: Dict[str, RunnerConfig] = field(default_factory=dict)
+
+    @classmethod
+    def from_toml_dict(cls, data: Dict[str, Any]) -> "TestConfig":
+        """Create config from TOML dict (typically [test] section).
+
+        Args:
+            data: Dict from TOML parsing
+
+        Returns:
+            TestConfig instance
+        """
+        runners = {}
+        runners_data = data.get("runners", {})
+        for name, runner_data in runners_data.items():
+            runners[name] = RunnerConfig.from_toml_dict(runner_data)
+
+        return cls(
+            default_runner=str(data.get("default_runner", "pytest")),
+            runners=runners,
+        )
+
+    def get_runner(self, name: Optional[str] = None) -> Optional[RunnerConfig]:
+        """Get runner config by name.
+
+        Args:
+            name: Runner name, or None to use default
+
+        Returns:
+            RunnerConfig if found, None otherwise
+        """
+        runner_name = name or self.default_runner
+        return self.runners.get(runner_name)
+
+
+@dataclass
+class ResearchConfig:
+    """Configuration for research workflows (CHAT, CONSENSUS, THINKDEEP, IDEATE).
+
+    Attributes:
+        enabled: Master switch for research tools
+        storage_path: Directory for research state persistence (default: ~/.foundry-mcp/research)
+        storage_backend: Storage backend type (currently only 'file' supported)
+        ttl_hours: Time-to-live for stored states in hours
+        max_messages_per_thread: Maximum messages retained in a conversation thread
+        default_provider: Default LLM provider for single-model workflows
+        consensus_providers: List of provider IDs for CONSENSUS workflow
+        thinkdeep_max_depth: Maximum investigation depth for THINKDEEP workflow
+        ideate_perspectives: List of perspectives for IDEATE brainstorming
+    """
+
+    enabled: bool = True
+    storage_path: str = ""  # Empty = use default (~/.foundry-mcp/research)
+    storage_backend: str = "file"
+    ttl_hours: int = 24
+    max_messages_per_thread: int = 100
+    default_provider: str = "gemini"
+    consensus_providers: List[str] = field(
+        default_factory=lambda: ["gemini", "claude"]
+    )
+    thinkdeep_max_depth: int = 5
+    ideate_perspectives: List[str] = field(
+        default_factory=lambda: ["technical", "creative", "practical", "visionary"]
+    )
+
+    @classmethod
+    def from_toml_dict(cls, data: Dict[str, Any]) -> "ResearchConfig":
+        """Create config from TOML dict (typically [research] section).
+
+        Args:
+            data: Dict from TOML parsing
+
+        Returns:
+            ResearchConfig instance
+        """
+        # Parse consensus_providers - handle both string and list
+        consensus_providers = data.get("consensus_providers", ["gemini", "claude"])
+        if isinstance(consensus_providers, str):
+            consensus_providers = [p.strip() for p in consensus_providers.split(",")]
+
+        # Parse ideate_perspectives - handle both string and list
+        ideate_perspectives = data.get(
+            "ideate_perspectives", ["technical", "creative", "practical", "visionary"]
+        )
+        if isinstance(ideate_perspectives, str):
+            ideate_perspectives = [p.strip() for p in ideate_perspectives.split(",")]
+
+        return cls(
+            enabled=_parse_bool(data.get("enabled", True)),
+            storage_path=str(data.get("storage_path", "")),
+            storage_backend=str(data.get("storage_backend", "file")),
+            ttl_hours=int(data.get("ttl_hours", 24)),
+            max_messages_per_thread=int(data.get("max_messages_per_thread", 100)),
+            default_provider=str(data.get("default_provider", "gemini")),
+            consensus_providers=consensus_providers,
+            thinkdeep_max_depth=int(data.get("thinkdeep_max_depth", 5)),
+            ideate_perspectives=ideate_perspectives,
+        )
+
+    def get_storage_path(self) -> Path:
+        """Get resolved storage path.
+
+        Returns:
+            Path to storage directory (creates if needed)
+        """
+        if self.storage_path:
+            return Path(self.storage_path).expanduser()
+        return Path.home() / ".foundry-mcp" / "research"
+
+
 _VALID_COMMIT_CADENCE = {"manual", "task", "phase"}
 
 
@@ -348,6 +535,7 @@ class ServerConfig:
     workspace_roots: List[Path] = field(default_factory=list)
     specs_dir: Optional[Path] = None
     journals_path: Optional[Path] = None
+    bikelane_dir: Optional[Path] = None  # Intake queue storage (default: specs/.bikelane)
 
     # Logging configuration
     log_level: str = "INFO"
@@ -359,7 +547,7 @@ class ServerConfig:
 
     # Server configuration
     server_name: str = "foundry-mcp"
-    server_version: str = "0.1.0"
+    server_version: str = field(default_factory=lambda: _PACKAGE_VERSION)
 
     # Git workflow configuration
     git: GitSettings = field(default_factory=GitSettings)
@@ -379,6 +567,12 @@ class ServerConfig:
     # Dashboard configuration
     dashboard: DashboardConfig = field(default_factory=DashboardConfig)
 
+    # Test runner configuration
+    test: TestConfig = field(default_factory=TestConfig)
+
+    # Research workflows configuration
+    research: ResearchConfig = field(default_factory=ResearchConfig)
+
     @classmethod
     def from_env(cls, config_file: Optional[str] = None) -> "ServerConfig":
         """
@@ -426,6 +620,8 @@ class ServerConfig:
                     self.specs_dir = Path(ws["specs_dir"])
                 if "journals_path" in ws:
                     self.journals_path = Path(ws["journals_path"])
+                if "bikelane_dir" in ws:
+                    self.bikelane_dir = Path(ws["bikelane_dir"])
 
             # Logging settings
             if "logging" in data:
@@ -499,6 +695,14 @@ class ServerConfig:
             if "dashboard" in data:
                 self.dashboard = DashboardConfig.from_toml_dict(data["dashboard"])
 
+            # Test runner settings
+            if "test" in data:
+                self.test = TestConfig.from_toml_dict(data["test"])
+
+            # Research workflows settings
+            if "research" in data:
+                self.research = ResearchConfig.from_toml_dict(data["research"])
+
         except Exception as e:
             logger.error(f"Error loading config file {path}: {e}")
 
@@ -516,6 +720,10 @@ class ServerConfig:
         if journals := os.environ.get("FOUNDRY_MCP_JOURNALS_PATH"):
             self.journals_path = Path(journals)
 
+        # Bikelane directory (intake queue storage)
+        if bikelane := os.environ.get("FOUNDRY_MCP_BIKELANE_DIR"):
+            self.bikelane_dir = Path(bikelane)
+
         # Log level
         if level := os.environ.get("FOUNDRY_MCP_LOG_LEVEL"):
             self.log_level = level.upper()
@@ -689,6 +897,28 @@ class ServerConfig:
 
         return key in self.api_keys
 
+    def get_bikelane_dir(self, specs_dir: Optional[Path] = None) -> Path:
+        """
+        Get the resolved bikelane directory path.
+
+        Priority:
+        1. Explicitly configured bikelane_dir (from TOML or env var)
+        2. Default: specs_dir/.bikelane (where specs_dir is resolved)
+
+        Args:
+            specs_dir: Optional specs directory to use for default path.
+                      If not provided, uses self.specs_dir or "./specs"
+
+        Returns:
+            Path to bikelane directory
+        """
+        if self.bikelane_dir is not None:
+            return self.bikelane_dir.expanduser()
+
+        # Fall back to default: specs/.bikelane
+        base_specs = specs_dir or self.specs_dir or Path("./specs")
+        return base_specs / ".bikelane"
+
     def setup_logging(self) -> None:
         """Configure logging based on settings."""
         level = getattr(logging, self.log_level, logging.INFO)

foundry_mcp/core/ai_consultation.py

@@ -44,7 +44,7 @@ import hashlib
 import json
 import logging
 import time
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Sequence, Union
@@ -1305,6 +1305,143 @@ class ConsultationOrchestrator:
             warnings=warnings,
         )
 
+    async def _execute_parallel_providers_with_fallback_async(
+        self,
+        request: ConsultationRequest,
+        prompt: str,
+        all_providers: List[ResolvedProvider],
+        min_models: int = 1,
+    ) -> ConsensusResult:
+        """
+        Execute providers in parallel with sequential fallback on failures.
+
+        Uses a two-phase approach:
+        1. Execute first min_models providers in parallel
+        2. If any fail and fallback_enabled, try remaining providers sequentially
+           until min_models succeed or providers exhausted
+
+        Args:
+            request: The consultation request
+            prompt: The rendered prompt
+            all_providers: Complete priority list of providers to try
+            min_models: Minimum successful models required
+
+        Returns:
+            ConsensusResult with all attempted provider responses
+        """
+        start_time = time.time()
+        warnings: List[str] = []
+        all_responses: List[ProviderResponse] = []
+
+        if not all_providers:
+            return ConsensusResult(
+                workflow=request.workflow,
+                responses=[],
+                duration_ms=0.0,
+                warnings=["No providers available for parallel execution"],
+            )
+
+        # Phase 1: Initial parallel execution of first min_models providers
+        initial_providers = all_providers[:min_models]
+        logger.debug(
+            f"Phase 1: Executing {len(initial_providers)} providers in parallel"
+        )
+
+        tasks = [
+            self._execute_single_provider_async(request, prompt, resolved)
+            for resolved in initial_providers
+        ]
+        initial_responses: List[ProviderResponse] = await asyncio.gather(*tasks)
+        all_responses.extend(initial_responses)
+
+        # Count successes and log failures
+        # A response is only truly successful if it has non-empty content
+        successful_count = sum(
+            1 for r in initial_responses if r.success and r.content.strip()
+        )
+        for response in initial_responses:
+            if not response.success:
+                warnings.append(
+                    f"Provider {response.provider_id} failed: {response.error}"
+                )
+            elif not response.content.strip():
+                warnings.append(
+                    f"Provider {response.provider_id} returned empty content"
+                )
+
+        # Phase 2: Sequential fallback if needed and enabled
+        if successful_count < min_models and self._config.fallback_enabled:
+            needed = min_models - successful_count
+            remaining_providers = all_providers[min_models:]
+
+            if remaining_providers:
+                warnings.append(
+                    f"Initial parallel execution yielded {successful_count}/{min_models} "
+                    f"successes, attempting fallback for {needed} more"
+                )
+
+                for fallback_provider in remaining_providers:
+                    # Skip if already tried (shouldn't happen, but safety check)
+                    if any(
+                        r.provider_id == fallback_provider.provider_id
+                        for r in all_responses
+                    ):
+                        continue
+
+                    # Check if provider is available
+                    if not check_provider_available(fallback_provider.provider_id):
+                        warnings.append(
+                            f"Fallback provider {fallback_provider.provider_id} "
+                            "is not available, skipping"
+                        )
+                        continue
+
+                    logger.debug(
+                        f"Fallback attempt: trying provider {fallback_provider.provider_id}"
+                    )
+
+                    response = await self._execute_single_provider_async(
+                        request, prompt, fallback_provider
+                    )
+                    all_responses.append(response)
+
+                    if response.success and response.content.strip():
+                        successful_count += 1
+                        warnings.append(
+                            f"Fallback provider {fallback_provider.provider_id} succeeded"
+                        )
+                        if successful_count >= min_models:
+                            logger.debug(
+                                f"Reached {min_models} successful providers via fallback"
+                            )
+                            break
+                    elif response.success and not response.content.strip():
+                        warnings.append(
+                            f"Fallback provider {fallback_provider.provider_id} "
+                            "returned empty content"
+                        )
+                    else:
+                        warnings.append(
+                            f"Fallback provider {fallback_provider.provider_id} "
+                            f"failed: {response.error}"
+                        )
+
+        duration_ms = (time.time() - start_time) * 1000
+
+        # Final warning if still insufficient
+        if successful_count < min_models:
+            warnings.append(
+                f"Only {successful_count} of {min_models} required models succeeded "
+                f"after trying {len(all_responses)} provider(s)"
+            )
+
+        return ConsensusResult(
+            workflow=request.workflow,
+            responses=all_responses,
+            duration_ms=duration_ms,
+            warnings=warnings,
+        )
+
     def _execute_with_fallback(
         self,
         request: ConsultationRequest,
@@ -1490,6 +1627,10 @@ class ConsultationOrchestrator:
         workflow_config = self._config.get_workflow_config(effective_workflow)
         min_models = workflow_config.min_models
 
+        # Apply workflow-specific timeout override if configured
+        if workflow_config.timeout_override is not None:
+            request = replace(request, timeout=workflow_config.timeout_override)
+
         # Generate cache key
         cache_key = self._generate_cache_key(request)
 
@@ -1533,14 +1674,10 @@ class ConsultationOrchestrator:
         providers = self._get_providers_to_try(request)
 
         if min_models > 1:
-            # Multi-model mode: execute providers in parallel
-            # Limit to min_models providers (or all available if fewer)
-            providers_to_use = (
-                providers[:min_models] if len(providers) >= min_models else providers
-            )
-
-            result = await self._execute_parallel_providers_async(
-                request, prompt, providers_to_use, min_models
+            # Multi-model mode: execute providers in parallel with fallback support
+            # Pass full provider list - fallback will try additional providers if needed
+            result = await self._execute_parallel_providers_with_fallback_async(
+                request, prompt, providers, min_models
             )
             return result
         else:

foundry_mcp/core/discovery.py

@@ -925,11 +925,11 @@ LLM_TOOL_METADATA: Dict[str, ToolMetadata] = {
             ParameterMetadata(
                 name="review_type",
                 type=ParameterType.STRING,
-                description="Type of review to perform",
+                description="Type of review to perform (defaults to config value, typically 'full')",
                 required=False,
-                default="quick",
+                default="full",
                 constraints={"enum": ["quick", "full", "security", "feasibility"]},
-                examples=["quick", "full", "security"],
+                examples=["full", "quick", "security"],
             ),
             ParameterMetadata(
                 name="tools",
@@ -965,13 +965,13 @@ LLM_TOOL_METADATA: Dict[str, ToolMetadata] = {
         related_tools=["review-list-tools", "review-list-plan-tools", "spec-review-fidelity"],
         examples=[
             {
-                "description": "Quick review of a specification",
-                "input": {"spec_id": "feature-auth-001", "review_type": "quick"},
+                "description": "Full review of a specification",
+                "input": {"spec_id": "feature-auth-001", "review_type": "full"},
                 "output": {
                     "success": True,
                     "data": {
                         "spec_id": "feature-auth-001",
-                        "review_type": "quick",
+                        "review_type": "full",
                         "findings": [],
                         "suggestions": ["Consider adding error handling"],
                     },

foundry_mcp/core/error_store.py

@@ -137,7 +137,7 @@ class FileErrorStore(ErrorStore):
     for efficient querying. Thread-safe with file locking for concurrent access.
 
     Directory structure:
-        .cache/foundry-mcp/errors/
+        ~/.foundry-mcp/errors/
             errors.jsonl     - Append-only error log
             index.json       - Fingerprint -> metadata mapping
             stats.json       - Pre-computed statistics (updated periodically)
@@ -579,7 +579,7 @@ def get_error_store(storage_path: Optional[str | Path] = None) -> ErrorStore:
         if _error_store is None:
             if storage_path is None:
                 # Default path
-                storage_path = Path.home() / ".cache" / "foundry-mcp" / "errors"
+                storage_path = Path.home() / ".foundry-mcp" / "errors"
             _error_store = FileErrorStore(storage_path)
 
         return _error_store