foundry-mcp 0.3.3__py3-none-any.whl → 0.8.10__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,9 +13,8 @@ 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
 from foundry_mcp.core.observability import audit_log, get_metrics, mcp_tool
 from foundry_mcp.core.responses import (
@@ -32,28 +31,68 @@ from foundry_mcp.tools.unified.router import (
 
 logger = logging.getLogger(__name__)
 _metrics = get_metrics()
-_flag_service = get_flag_service()
-try:
-    _flag_service.register(
-        FeatureFlag(
-            name="environment_tools",
-            description="Environment readiness and workspace tooling",
-            state=FlagState.BETA,
-            default_enabled=True,
-        )
-    )
-except ValueError:
-    pass
 
-_DEFAULT_TOML_CONTENT = """[workspace]
+_DEFAULT_TOML_TEMPLATE = """[workspace]
 specs_dir = "./specs"
 
+[logging]
+level = "INFO"
+structured = true
+
+[tools]
+# Disable tools to reduce context window usage
+# Available: health, plan, pr, error, metrics, journal, authoring, review,
+#            spec, task, provider, environment, lifecycle, verification,
+#            server, test, research
+disabled_tools = ["error", "metrics", "health"]
+
 [workflow]
 mode = "single"
 auto_validate = true
-
-[logging]
-level = "INFO"
+journal_enabled = true
+
+[implement]
+# Default flags for /implement command (can be overridden via CLI flags)
+auto = false      # --auto: skip prompts between tasks
+delegate = false  # --delegate: use subagent(s) for implementation
+parallel = false  # --parallel: run subagents concurrently (implies delegate)
+
+[consultation]
+# priority = []  # Appended by setup based on detected providers
+default_timeout = 300
+
+[research]
+# Research tool configuration (chat, consensus, thinkdeep, ideate, deep)
+# default_provider = "[cli]provider:model"  # Appended by setup
+# consensus_providers = []  # Appended by setup (same as consultation.priority)
+max_retries = 2
+retry_delay = 5.0
+fallback_enabled = true
+cache_ttl = 3600
+
+[research.deep]
+# Deep research workflow settings
+max_iterations = 3
+max_sub_queries = 5
+max_sources_per_query = 5
+follow_links = true
+max_concurrent = 3
+timeout_per_operation = 120
+
+[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 +180,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,7 +228,9 @@ _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",
+    "get-config": "Read configuration sections from foundry-mcp.toml",
 }
 
 
@@ -197,19 +243,8 @@ def _request_id() -> str:
 
 
 def _feature_flag_blocked(request_id: str) -> Optional[dict]:
-    if _flag_service.is_enabled("environment_tools"):
-        return None
-
-    return asdict(
-        error_response(
-            "Environment tools are disabled by feature flag",
-            error_code=ErrorCode.FEATURE_DISABLED,
-            error_type=ErrorType.FEATURE_FLAG,
-            data={"feature": "environment_tools"},
-            remediation="Enable the 'environment_tools' feature flag to call environment actions.",
-            request_id=request_id,
-        )
-    )
+    # Feature flags disabled - always allow
+    return None
 
 
 def _validation_error(
@@ -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
@@ -837,6 +1056,169 @@ def _handle_setup(
         )
 
 
+def _handle_get_config(
+    *,
+    config: ServerConfig,  # noqa: ARG001 - config object available but we read TOML directly
+    sections: Optional[List[str]] = None,
+    key: Optional[str] = None,
+    **_: Any,
+) -> dict:
+    """Read configuration sections from foundry-mcp.toml.
+
+    Returns the requested sections from the TOML config file.
+    Supported sections: implement, git.
+
+    Args:
+        sections: List of section names to return (default: all supported sections)
+        key: Specific key within section (only valid when requesting single section)
+    """
+    import tomllib
+
+    request_id = _request_id()
+    blocked = _feature_flag_blocked(request_id)
+    if blocked:
+        return blocked
+
+    # Validate sections parameter
+    supported_sections = {"implement", "git"}
+    if sections is not None:
+        if not isinstance(sections, list):
+            return _validation_error(
+                action="get-config",
+                field="sections",
+                message="Expected a list of section names",
+                request_id=request_id,
+                code=ErrorCode.INVALID_FORMAT,
+            )
+        invalid = set(sections) - supported_sections
+        if invalid:
+            return _validation_error(
+                action="get-config",
+                field="sections",
+                message=f"Unsupported sections: {', '.join(sorted(invalid))}. Supported: {', '.join(sorted(supported_sections))}",
+                request_id=request_id,
+            )
+
+    # Validate key parameter
+    if key is not None:
+        if not isinstance(key, str):
+            return _validation_error(
+                action="get-config",
+                field="key",
+                message="Expected a string",
+                request_id=request_id,
+                code=ErrorCode.INVALID_FORMAT,
+            )
+        if sections is None or len(sections) != 1:
+            return _validation_error(
+                action="get-config",
+                field="key",
+                message="The 'key' parameter is only valid when requesting exactly one section",
+                request_id=request_id,
+            )
+
+    metric_key = _metric_name("get-config")
+    try:
+        # Find the TOML config file
+        toml_path = None
+        for candidate in ["foundry-mcp.toml", ".foundry-mcp.toml"]:
+            if Path(candidate).exists():
+                toml_path = Path(candidate)
+                break
+
+        if not toml_path:
+            _metrics.counter(metric_key, labels={"status": "not_found"})
+            return asdict(
+                error_response(
+                    "No foundry-mcp.toml config file found",
+                    error_code=ErrorCode.NOT_FOUND,
+                    error_type=ErrorType.NOT_FOUND,
+                    remediation="Run environment(action=setup) to create the config file",
+                    request_id=request_id,
+                )
+            )
+
+        # Read and parse TOML
+        with open(toml_path, "rb") as f:
+            data = tomllib.load(f)
+
+        # Determine which sections to return
+        requested = set(sections) if sections else supported_sections
+
+        # Build result with only supported sections
+        result: Dict[str, Any] = {}
+
+        if "implement" in requested and "implement" in data:
+            impl_data = data["implement"]
+            result["implement"] = {
+                "auto": impl_data.get("auto", False),
+                "delegate": impl_data.get("delegate", False),
+                "parallel": impl_data.get("parallel", False),
+            }
+
+        if "git" in requested and "git" in data:
+            git_data = data["git"]
+            result["git"] = {
+                "enabled": git_data.get("enabled", True),
+                "auto_commit": git_data.get("auto_commit", False),
+                "auto_push": git_data.get("auto_push", False),
+                "auto_pr": git_data.get("auto_pr", False),
+                "commit_cadence": git_data.get("commit_cadence", "task"),
+            }
+
+        # If sections were requested but not found, include them as empty/defaults
+        for section in requested:
+            if section not in result:
+                if section == "implement":
+                    result["implement"] = {
+                        "auto": False,
+                        "delegate": False,
+                        "parallel": False,
+                    }
+                elif section == "git":
+                    result["git"] = {
+                        "enabled": True,
+                        "auto_commit": False,
+                        "auto_push": False,
+                        "auto_pr": False,
+                        "commit_cadence": "task",
+                    }
+
+        # If a specific key was requested, extract just that value
+        if key is not None:
+            section_name = sections[0]  # Already validated to be exactly one section
+            section_data = result.get(section_name, {})
+            if key not in section_data:
+                return _validation_error(
+                    action="get-config",
+                    field="key",
+                    message=f"Key '{key}' not found in section '{section_name}'",
+                    request_id=request_id,
+                    code=ErrorCode.NOT_FOUND,
+                )
+            result = {section_name: {key: section_data[key]}}
+
+        _metrics.counter(metric_key, labels={"status": "success"})
+        return asdict(
+            success_response(
+                data={"sections": result, "config_file": str(toml_path)},
+                request_id=request_id,
+            )
+        )
+    except Exception as exc:
+        logger.exception("Error reading config")
+        _metrics.counter(metric_key, labels={"status": "error"})
+        return asdict(
+            error_response(
+                f"Failed to read config: {exc}",
+                error_code=ErrorCode.INTERNAL_ERROR,
+                error_type=ErrorType.INTERNAL,
+                remediation="Check foundry-mcp.toml syntax and retry",
+                request_id=request_id,
+            )
+        )
+
+
 _ENVIRONMENT_ROUTER = ActionRouter(
     tool_name="environment",
     actions=[
@@ -868,12 +1250,28 @@ _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,
             summary=_ACTION_SUMMARY["setup"],
             aliases=("sdd-setup", "sdd_setup"),
         ),
+        ActionDefinition(
+            name="get-config",
+            handler=_handle_get_config,
+            summary=_ACTION_SUMMARY["get-config"],
+            aliases=("config", "read-config", "get_config"),
+        ),
     ],
 )
 
@@ -914,6 +1312,8 @@ def register_unified_environment_tool(mcp: FastMCP, config: ServerConfig) -> Non
         permissions_preset: str = "full",
         create_toml: bool = True,
         dry_run: bool = False,
+        sections: Optional[List[str]] = None,
+        key: Optional[str] = None,
     ) -> dict:
         payload = {
             "path": path,
@@ -926,6 +1326,8 @@ def register_unified_environment_tool(mcp: FastMCP, config: ServerConfig) -> Non
             "permissions_preset": permissions_preset,
             "create_toml": create_toml,
             "dry_run": dry_run,
+            "sections": sections,
+            "key": key,
         }
         return _dispatch_environment_action(
             action=action, payload=payload, config=config

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: