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

foundry_mcp/tools/unified/documentation_helpers.py

@@ -45,6 +45,49 @@ def _build_spec_requirements(
     return "\n".join(lines) if lines else "*No requirements available*"
 
 
+def _split_file_paths(value: Any) -> List[str]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        parts: List[str] = []
+        for item in value:
+            parts.extend(_split_file_paths(item))
+        return parts
+    if isinstance(value, str):
+        segments = [part.strip() for part in value.split(",")]
+        return [segment for segment in segments if segment]
+    return [str(value)]
+
+
+def _normalize_for_comparison(path_value: str, workspace_root: Optional[Path]) -> str:
+    raw_path = Path(path_value)
+    if raw_path.is_absolute() and workspace_root:
+        try:
+            raw_path = raw_path.relative_to(workspace_root)
+        except ValueError:
+            pass
+    if workspace_root and raw_path.parts and raw_path.parts[0] == workspace_root.name:
+        raw_path = Path(*raw_path.parts[1:])
+    return raw_path.as_posix()
+
+
+def _resolve_path(path_value: str, workspace_root: Optional[Path]) -> Path:
+    raw_path = Path(path_value)
+    candidates: List[Path] = []
+    if raw_path.is_absolute():
+        candidates.append(raw_path)
+    else:
+        candidates.append(raw_path)
+        if workspace_root:
+            candidates.append(workspace_root / raw_path)
+            if raw_path.parts and raw_path.parts[0] == workspace_root.name:
+                candidates.append(workspace_root / Path(*raw_path.parts[1:]))
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return candidates[0] if candidates else raw_path
+
+
 def _build_implementation_artifacts(
     spec_data: Dict[str, Any],
     task_id: Optional[str],
@@ -52,21 +95,32 @@ def _build_implementation_artifacts(
     files: Optional[List[str]],
     incremental: bool,
     base_branch: str,
+    workspace_root: Optional[Path] = None,
 ) -> str:
     lines: list[str] = []
     file_paths: list[str] = []
+    if workspace_root is not None and not isinstance(workspace_root, Path):
+        workspace_root = Path(str(workspace_root))
     if files:
-        file_paths = list(files)
+        file_paths = _split_file_paths(files)
     elif task_id:
         task = _find_task(spec_data, task_id)
         if task and task.get("metadata", {}).get("file_path"):
-            file_paths = [task["metadata"]["file_path"]]
+            file_paths = _split_file_paths(task["metadata"]["file_path"])
     elif phase_id:
         phase = _find_phase(spec_data, phase_id)
         if phase:
             for child in _get_child_nodes(spec_data, phase):
                 if child.get("metadata", {}).get("file_path"):
-                    file_paths.append(child["metadata"]["file_path"])
+                    file_paths.extend(_split_file_paths(child["metadata"]["file_path"]))
+    if file_paths:
+        deduped: List[str] = []
+        seen = set()
+        for file_path in file_paths:
+            if file_path not in seen:
+                seen.add(file_path)
+                deduped.append(file_path)
+        file_paths = deduped
     if incremental:
         try:
             import subprocess
@@ -82,16 +136,25 @@ def _build_implementation_artifacts(
                     result.stdout.strip().split("\n") if result.stdout else []
                 )
                 if file_paths:
-                    file_paths = [path for path in file_paths if path in changed_files]
+                    changed_set = {
+                        _normalize_for_comparison(path, workspace_root)
+                        for path in changed_files
+                        if path
+                    }
+                    file_paths = [
+                        path
+                        for path in file_paths
+                        if _normalize_for_comparison(path, workspace_root) in changed_set
+                    ]
                 else:
-                    file_paths = changed_files
+                    file_paths = [path for path in changed_files if path]
                 lines.append(
                     f"*Incremental review: {len(file_paths)} changed files since {base_branch}*\n"
                 )
         except Exception:
             lines.append(f"*Warning: Could not get git diff from {base_branch}*\n")
     for file_path in file_paths[:5]:
-        path = Path(file_path)
+        path = _resolve_path(file_path, workspace_root)
         if path.exists():
             try:
                 content = path.read_text(encoding="utf-8")

foundry_mcp/tools/unified/environment.py

@@ -13,7 +13,7 @@ from typing import Any, Dict, List, Optional, cast
 
 from mcp.server.fastmcp import FastMCP
 
-from foundry_mcp.config import ServerConfig
+from foundry_mcp.config import ServerConfig, _PACKAGE_VERSION
 from foundry_mcp.core.context import generate_correlation_id, get_correlation_id
 from foundry_mcp.core.feature_flags import FeatureFlag, FlagState, get_flag_service
 from foundry_mcp.core.naming import canonical_tool
@@ -45,15 +45,44 @@ try:
 except ValueError:
     pass
 
-_DEFAULT_TOML_CONTENT = """[workspace]
+_DEFAULT_TOML_TEMPLATE = """[workspace]
 specs_dir = "./specs"
 
+[logging]
+level = "INFO"
+structured = true
+
+[server]
+name = "foundry-mcp"
+version = "{version}"
+
 [workflow]
 mode = "single"
 auto_validate = true
-
-[logging]
-level = "INFO"
+journal_enabled = true
+
+[consultation]
+# priority = []  # Appended by setup based on detected providers
+default_timeout = 300
+max_retries = 2
+retry_delay = 5.0
+fallback_enabled = true
+cache_ttl = 3600
+
+[consultation.workflows.fidelity_review]
+min_models = 2
+timeout_override = 600.0
+default_review_type = "full"
+
+[consultation.workflows.plan_review]
+min_models = 2
+timeout_override = 180.0
+default_review_type = "full"
+
+[consultation.workflows.markdown_plan_review]
+min_models = 2
+timeout_override = 180.0
+default_review_type = "full"
 """
 
 
@@ -141,11 +170,16 @@ def _update_permissions(
     return {"changes": changes}
 
 
+def _get_default_toml_content() -> str:
+    """Get default TOML content with current package version."""
+    return _DEFAULT_TOML_TEMPLATE.format(version=_PACKAGE_VERSION)
+
+
 def _write_default_toml(toml_path: Path) -> None:
     """Write default foundry-mcp.toml configuration file."""
 
     with open(toml_path, "w") as handle:
-        handle.write(_DEFAULT_TOML_CONTENT)
+        handle.write(_get_default_toml_content())
 
 
 def _init_specs_directory(base_path: Path, dry_run: bool) -> Dict[str, Any]:
@@ -184,6 +218,7 @@ _ACTION_SUMMARY = {
     "verify-env": "Validate runtimes, packages, and workspace environment",
     "init": "Initialize the standard specs/ workspace structure",
     "detect": "Detect repository topology (project type, specs/docs)",
+    "detect-test-runner": "Detect appropriate test runner for the project",
     "setup": "Complete SDD setup with permissions + config",
 }
 
@@ -545,6 +580,190 @@ def _handle_detect_topology(
         )
 
 
+def _handle_detect_test_runner(
+    *,
+    config: ServerConfig,  # noqa: ARG001 - reserved for future hooks
+    path: Optional[str] = None,
+    **_: Any,
+) -> dict:
+    """Detect appropriate test runner based on project type and configuration files.
+
+    Returns a structured response with detected runners, confidence levels, and
+    a recommended default runner.
+
+    Detection rules:
+    - Python: pyproject.toml, setup.py, requirements.txt, Pipfile → pytest
+    - Go: go.mod → go
+    - Jest: jest.config.* or package.json with "jest" key → jest (precedence over npm)
+    - Node: package.json with "test" script → npm
+    - Rust: Cargo.toml + Makefile present → make
+    """
+    request_id = _request_id()
+    blocked = _feature_flag_blocked(request_id)
+    if blocked:
+        return blocked
+
+    if path is not None and not isinstance(path, str):
+        return _validation_error(
+            action="detect-test-runner",
+            field="path",
+            message="Directory path must be a string",
+            request_id=request_id,
+        )
+
+    metric_key = _metric_name("detect-test-runner")
+    try:
+        base_path = Path(path) if path else Path.cwd()
+
+        detected_runners: List[Dict[str, Any]] = []
+
+        # Python detection (highest precedence for Python projects)
+        python_primary = ["pyproject.toml", "setup.py"]
+        python_secondary = ["requirements.txt", "Pipfile"]
+
+        for marker in python_primary:
+            if (base_path / marker).exists():
+                detected_runners.append({
+                    "runner_name": "pytest",
+                    "project_type": "python",
+                    "confidence": "high",
+                    "reason": f"{marker} found",
+                })
+                break
+        else:
+            # Check secondary markers only if no primary found
+            for marker in python_secondary:
+                if (base_path / marker).exists():
+                    detected_runners.append({
+                        "runner_name": "pytest",
+                        "project_type": "python",
+                        "confidence": "medium",
+                        "reason": f"{marker} found",
+                    })
+                    break
+
+        # Go detection
+        if (base_path / "go.mod").exists():
+            detected_runners.append({
+                "runner_name": "go",
+                "project_type": "go",
+                "confidence": "high",
+                "reason": "go.mod found",
+            })
+
+        # Node detection - Jest takes precedence over npm
+        jest_configs = [
+            "jest.config.js",
+            "jest.config.ts",
+            "jest.config.mjs",
+            "jest.config.cjs",
+            "jest.config.json",
+        ]
+
+        jest_detected = False
+        for jest_config in jest_configs:
+            if (base_path / jest_config).exists():
+                detected_runners.append({
+                    "runner_name": "jest",
+                    "project_type": "node",
+                    "confidence": "high",
+                    "reason": f"{jest_config} found",
+                })
+                jest_detected = True
+                break
+
+        # Check package.json for jest config or test script
+        package_json_path = base_path / "package.json"
+        if package_json_path.exists():
+            try:
+                with open(package_json_path, "r") as f:
+                    pkg = json.load(f)
+
+                # Jest config in package.json takes precedence
+                if not jest_detected and "jest" in pkg:
+                    detected_runners.append({
+                        "runner_name": "jest",
+                        "project_type": "node",
+                        "confidence": "high",
+                        "reason": "jest key in package.json",
+                    })
+                    jest_detected = True
+
+                # npm test script (only if jest not already detected)
+                if not jest_detected:
+                    scripts = pkg.get("scripts", {})
+                    if "test" in scripts:
+                        detected_runners.append({
+                            "runner_name": "npm",
+                            "project_type": "node",
+                            "confidence": "high",
+                            "reason": "test script in package.json",
+                        })
+            except (json.JSONDecodeError, OSError):
+                # If package.json is invalid, skip Node detection
+                pass
+
+        # Rust detection - only if BOTH Cargo.toml and Makefile exist
+        cargo_exists = (base_path / "Cargo.toml").exists()
+        makefile_exists = (base_path / "Makefile").exists() or (
+            base_path / "makefile"
+        ).exists()
+
+        if cargo_exists and makefile_exists:
+            detected_runners.append({
+                "runner_name": "make",
+                "project_type": "rust",
+                "confidence": "medium",
+                "reason": "Cargo.toml + Makefile found",
+            })
+
+        # Determine recommended default based on precedence order from plan
+        # Priority: python (1) > go (2) > jest (3) > npm (4) > make (5)
+        precedence_order = ["pytest", "go", "jest", "npm", "make"]
+        recommended_default: Optional[str] = None
+
+        for runner_name in precedence_order:
+            for runner in detected_runners:
+                if runner["runner_name"] == runner_name:
+                    recommended_default = runner_name
+                    break
+            if recommended_default:
+                break
+
+        data: Dict[str, Any] = {
+            "detected_runners": detected_runners,
+            "recommended_default": recommended_default,
+        }
+
+        warnings: List[str] = []
+        if not detected_runners:
+            warnings.append(
+                "No test runners detected. Configure [test] section manually in "
+                "foundry-mcp.toml if tests are needed."
+            )
+
+        _metrics.counter(metric_key, labels={"status": "success"})
+        return asdict(
+            success_response(
+                data=data,
+                warnings=warnings or None,
+                request_id=request_id,
+            )
+        )
+    except Exception as exc:
+        logger.exception("Error detecting test runner")
+        _metrics.counter(metric_key, labels={"status": "error"})
+        return asdict(
+            error_response(
+                f"Failed to detect test runner: {exc}",
+                error_code=ErrorCode.INTERNAL_ERROR,
+                error_type=ErrorType.INTERNAL,
+                remediation="Verify the directory exists and retry",
+                request_id=request_id,
+            )
+        )
+
+
 def _handle_verify_environment(
     *,
     config: ServerConfig,  # noqa: ARG001 - reserved for future hooks
@@ -868,6 +1087,16 @@ _ENVIRONMENT_ROUTER = ActionRouter(
             summary=_ACTION_SUMMARY["detect"],
             aliases=("sdd-detect-topology", "sdd_detect_topology"),
         ),
+        ActionDefinition(
+            name="detect-test-runner",
+            handler=_handle_detect_test_runner,
+            summary=_ACTION_SUMMARY["detect-test-runner"],
+            aliases=(
+                "detect_test_runner",
+                "sdd-detect-test-runner",
+                "sdd_detect_test_runner",
+            ),
+        ),
         ActionDefinition(
             name="setup",
             handler=_handle_setup,

foundry_mcp/tools/unified/error.py

@@ -332,7 +332,24 @@ def perform_error_cleanup(
 
 
 def _handle_error_list(*, config: ServerConfig, **payload: Any) -> dict:
-    return perform_error_list(config=config, **payload)
+    # Filter out parameters not accepted by perform_error_list
+    filtered_payload = {
+        k: v
+        for k, v in payload.items()
+        if k
+        in (
+            "tool_name",
+            "error_code",
+            "error_type",
+            "fingerprint",
+            "provider_id",
+            "since",
+            "until",
+            "limit",
+            "cursor",
+        )
+    }
+    return perform_error_list(config=config, **filtered_payload)
 
 
 def _handle_error_get(*, config: ServerConfig, **payload: Any) -> dict:

foundry_mcp/tools/unified/lifecycle.py

@@ -209,6 +209,7 @@ def _handle_move(
     spec_id: Optional[str] = None,
     to_folder: Optional[str] = None,
     path: Optional[str] = None,
+    force: Optional[bool] = None,  # Unused, accepted for router compatibility
 ) -> dict:
     action = "move"
     request_id = _request_id()
@@ -293,7 +294,9 @@ def _handle_activate(
     *,
     config: ServerConfig,
     spec_id: Optional[str] = None,
+    to_folder: Optional[str] = None,  # Unused, accepted for router compatibility
     path: Optional[str] = None,
+    force: Optional[bool] = None,  # Unused, accepted for router compatibility
 ) -> dict:
     action = "activate"
     request_id = _request_id()
@@ -356,6 +359,7 @@ def _handle_complete(
     *,
     config: ServerConfig,
     spec_id: Optional[str] = None,
+    to_folder: Optional[str] = None,  # Unused, accepted for router compatibility
     force: Optional[bool] = False,
     path: Optional[str] = None,
 ) -> dict:
@@ -429,7 +433,9 @@ def _handle_archive(
     *,
     config: ServerConfig,
     spec_id: Optional[str] = None,
+    to_folder: Optional[str] = None,  # Unused, accepted for router compatibility
     path: Optional[str] = None,
+    force: Optional[bool] = None,  # Unused, accepted for router compatibility
 ) -> dict:
     action = "archive"
     request_id = _request_id()
@@ -492,7 +498,9 @@ def _handle_state(
     *,
     config: ServerConfig,
     spec_id: Optional[str] = None,
+    to_folder: Optional[str] = None,  # Unused, accepted for router compatibility
     path: Optional[str] = None,
+    force: Optional[bool] = None,  # Unused, accepted for router compatibility
 ) -> dict:
     action = "state"
     request_id = _request_id()

foundry_mcp/tools/unified/plan.py

@@ -339,6 +339,7 @@ def perform_plan_review(
 
         consensus_info: Optional[dict] = None
         provider_used: Optional[str] = None
+        provider_reviews: list[dict[str, str]] = []
 
         if isinstance(result, ConsultationResult):
             if not result.success:
@@ -362,16 +363,125 @@ def perform_plan_review(
                         remediation="Check AI provider configuration or try again later",
                     )
                 )
-            review_content = result.primary_content
+
             providers_consulted = [r.provider_id for r in result.responses]
             provider_used = providers_consulted[0] if providers_consulted else "unknown"
+
+            # Extract failed provider details for visibility
+            failed_providers = [
+                {"provider_id": r.provider_id, "error": r.error}
+                for r in result.responses
+                if not r.success
+            ]
+            # Filter for truly successful responses (success=True AND non-empty content)
+            successful_responses = [
+                r for r in result.responses if r.success and r.content.strip()
+            ]
+            successful_providers = [r.provider_id for r in successful_responses]
+
             consensus_info = {
                 "providers_consulted": providers_consulted,
                 "successful": result.agreement.successful_providers
                 if result.agreement
                 else 0,
                 "failed": result.agreement.failed_providers if result.agreement else 0,
+                "successful_providers": successful_providers,
+                "failed_providers": failed_providers,
             }
+
+            # Save individual provider review files and optionally run synthesis
+            if len(successful_responses) >= 2:
+                # Multi-model mode: save per-provider files, then synthesize
+                specs_dir = find_specs_directory()
+                if specs_dir is None:
+                    return asdict(
+                        error_response(
+                            "No specs directory found for storing plan review",
+                            error_code=ErrorCode.NOT_FOUND,
+                            error_type=ErrorType.NOT_FOUND,
+                            remediation="Create a specs/ directory with pending/active/completed/archived subdirectories",
+                        )
+                    )
+
+                plan_reviews_dir = specs_dir / ".plan-reviews"
+                plan_reviews_dir.mkdir(parents=True, exist_ok=True)
+
+                # Save each provider's review to a separate file
+                model_reviews_text = ""
+                for response in successful_responses:
+                    provider_file = (
+                        plan_reviews_dir
+                        / f"{plan_name}-{review_type}-{response.provider_id}.md"
+                    )
+                    provider_file.write_text(response.content, encoding="utf-8")
+                    provider_reviews.append(
+                        {"provider_id": response.provider_id, "path": str(provider_file)}
+                    )
+                    model_reviews_text += (
+                        f"\n---\n## Review by {response.provider_id}\n\n"
+                        f"{response.content}\n"
+                    )
+
+                # Run synthesis call using first provider
+                logger.info(
+                    "Running synthesis for %d provider reviews: %s",
+                    len(successful_responses),
+                    successful_providers,
+                )
+                synthesis_request = ConsultationRequest(
+                    workflow=ConsultationWorkflow.PLAN_REVIEW,
+                    prompt_id="SYNTHESIS_PROMPT_V1",
+                    context={
+                        "spec_id": plan_name,
+                        "title": plan_name,
+                        "num_models": len(successful_responses),
+                        "model_reviews": model_reviews_text,
+                    },
+                    provider_id=successful_providers[0],
+                    timeout=ai_timeout,
+                )
+                try:
+                    synthesis_result = orchestrator.consult(
+                        synthesis_request, use_cache=consultation_cache
+                    )
+                except Exception as e:
+                    logger.error("Synthesis call crashed: %s", e, exc_info=True)
+                    synthesis_result = None
+
+                # Handle both ConsultationResult and ConsensusResult
+                synthesis_success = False
+                synthesis_content = None
+                if synthesis_result:
+                    if isinstance(synthesis_result, ConsultationResult) and synthesis_result.success:
+                        synthesis_content = synthesis_result.content
+                        consensus_info["synthesis_provider"] = synthesis_result.provider_id
+                        synthesis_success = bool(synthesis_content and synthesis_content.strip())
+                    elif isinstance(synthesis_result, ConsensusResult) and synthesis_result.success:
+                        synthesis_content = synthesis_result.primary_content
+                        consensus_info["synthesis_provider"] = synthesis_result.responses[0].provider_id if synthesis_result.responses else "unknown"
+                        synthesis_success = bool(synthesis_content and synthesis_content.strip())
+
+                if synthesis_success and synthesis_content:
+                    review_content = synthesis_content
+                else:
+                    # Synthesis failed - fall back to first provider's content
+                    error_detail = "unknown"
+                    if synthesis_result is None:
+                        error_detail = "synthesis crashed (see logs)"
+                    elif isinstance(synthesis_result, ConsultationResult):
+                        error_detail = synthesis_result.error or "empty response"
+                    elif isinstance(synthesis_result, ConsensusResult):
+                        error_detail = "empty synthesis content"
+                    logger.warning(
+                        "Synthesis call failed (%s), falling back to first provider's content",
+                        error_detail,
+                    )
+                    review_content = result.primary_content
+                    consensus_info["synthesis_failed"] = True
+                    consensus_info["synthesis_error"] = error_detail
+            else:
+                # Single successful provider - use its content directly (no synthesis needed)
+                review_content = result.primary_content
         else:  # pragma: no cover - defensive branch
             logger.error("Unknown consultation result type: %s", type(result))
             return asdict(
@@ -444,6 +554,8 @@ def perform_plan_review(
         "llm_status": llm_status,
         "provider_used": provider_used,
     }
+    if provider_reviews:
+        response_data["provider_reviews"] = provider_reviews
     if consensus_info:
         response_data["consensus"] = consensus_info