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

foundry_mcp/tools/unified/__init__.py

@@ -29,27 +29,46 @@ if TYPE_CHECKING:  # pragma: no cover - import-time typing only
 
 def register_unified_tools(mcp: "FastMCP", config: "ServerConfig") -> None:
     """Register all unified tool routers."""
-    register_unified_health_tool(mcp, config)
-    register_unified_plan_tool(mcp, config)
-    register_unified_pr_tool(mcp, config)
-    register_unified_error_tool(mcp, config)
-    register_unified_metrics_tool(mcp, config)
-    register_unified_journal_tool(mcp, config)
-    register_unified_authoring_tool(mcp, config)
-    register_unified_review_tool(mcp, config)
-    register_unified_spec_tool(mcp, config)
+    disabled = set(config.disabled_tools)
+
+    if "health" not in disabled:
+        register_unified_health_tool(mcp, config)
+    if "plan" not in disabled:
+        register_unified_plan_tool(mcp, config)
+    if "pr" not in disabled:
+        register_unified_pr_tool(mcp, config)
+    if "error" not in disabled:
+        register_unified_error_tool(mcp, config)
+    if "metrics" not in disabled:
+        register_unified_metrics_tool(mcp, config)
+    if "journal" not in disabled:
+        register_unified_journal_tool(mcp, config)
+    if "authoring" not in disabled:
+        register_unified_authoring_tool(mcp, config)
+    if "review" not in disabled:
+        register_unified_review_tool(mcp, config)
+    if "spec" not in disabled:
+        register_unified_spec_tool(mcp, config)
 
     from importlib import import_module
 
-    _task_router = import_module("foundry_mcp.tools.unified.task")
-    _task_router.register_unified_task_tool(mcp, config)
-    register_unified_provider_tool(mcp, config)
-    register_unified_environment_tool(mcp, config)
-    register_unified_lifecycle_tool(mcp, config)
-    register_unified_verification_tool(mcp, config)
-    register_unified_server_tool(mcp, config)
-    register_unified_test_tool(mcp, config)
-    register_unified_research_tool(mcp, config)
+    if "task" not in disabled:
+        _task_router = import_module("foundry_mcp.tools.unified.task")
+        _task_router.register_unified_task_tool(mcp, config)
+    if "provider" not in disabled:
+        register_unified_provider_tool(mcp, config)
+    if "environment" not in disabled:
+        register_unified_environment_tool(mcp, config)
+    if "lifecycle" not in disabled:
+        register_unified_lifecycle_tool(mcp, config)
+    if "verification" not in disabled:
+        register_unified_verification_tool(mcp, config)
+    if "server" not in disabled:
+        register_unified_server_tool(mcp, config)
+    if "test" not in disabled:
+        register_unified_test_tool(mcp, config)
+    if "research" not in disabled:
+        register_unified_research_tool(mcp, config)
 
 
 __all__ = [

foundry_mcp/tools/unified/authoring.py

@@ -13,7 +13,6 @@ from mcp.server.fastmcp import FastMCP
 
 from foundry_mcp.config import ServerConfig
 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.intake import IntakeStore, LockAcquisitionError, INTAKE_ID_PATTERN
 from foundry_mcp.core.naming import canonical_tool
 from foundry_mcp.core.observability import audit_log, get_metrics, mcp_tool
@@ -57,38 +56,6 @@ from foundry_mcp.tools.unified.router import (
 logger = logging.getLogger(__name__)
 _metrics = get_metrics()
 
-# Register intake_tools feature flag
-_flag_service = get_flag_service()
-try:
-    _flag_service.register(
-        FeatureFlag(
-            name="intake_tools",
-            description="Bikelane intake queue tools (add, list, dismiss)",
-            state=FlagState.EXPERIMENTAL,
-            default_enabled=False,
-        )
-    )
-except ValueError:
-    pass  # Flag already registered
-
-
-def _intake_feature_flag_blocked(request_id: str) -> Optional[dict]:
-    """Check if intake tools are blocked by feature flag."""
-    if _flag_service.is_enabled("intake_tools"):
-        return None
-
-    return asdict(
-        error_response(
-            "Intake tools are disabled by feature flag",
-            error_code=ErrorCode.FEATURE_DISABLED,
-            error_type=ErrorType.FEATURE_FLAG,
-            data={"feature": "intake_tools"},
-            remediation="Enable the 'intake_tools' feature flag to use intake actions.",
-            request_id=request_id,
-        )
-    )
-
-
 _ACTION_SUMMARY = {
     "spec-create": "Scaffold a new SDD specification",
     "spec-template": "List/show/apply spec templates",

foundry_mcp/tools/unified/environment.py

@@ -15,7 +15,6 @@ from mcp.server.fastmcp import FastMCP
 
 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,18 +31,6 @@ 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_TEMPLATE = """[workspace]
 specs_dir = "./specs"
@@ -52,23 +39,46 @@ specs_dir = "./specs"
 level = "INFO"
 structured = true
 
-[server]
-name = "foundry-mcp"
-version = "{version}"
+[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
 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
@@ -220,6 +230,7 @@ _ACTION_SUMMARY = {
     "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",
 }
 
 
@@ -232,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(
@@ -1056,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=[
@@ -1103,6 +1266,12 @@ _ENVIRONMENT_ROUTER = ActionRouter(
             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"),
+        ),
     ],
 )
 
@@ -1143,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,
@@ -1155,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/plan.py

@@ -19,6 +19,7 @@ from foundry_mcp.core.ai_consultation import (
     ConsultationWorkflow,
     ConsensusResult,
 )
+from foundry_mcp.core.llm_config import load_consultation_config
 from foundry_mcp.core.naming import canonical_tool
 from foundry_mcp.core.observability import get_metrics, mcp_tool
 from foundry_mcp.core.providers import available_providers
@@ -29,6 +30,7 @@ from foundry_mcp.core.responses import (
     error_response,
     success_response,
 )
+from foundry_mcp.core.llm_config import load_consultation_config
 from foundry_mcp.core.security import is_prompt_injection
 from foundry_mcp.core.spec import find_specs_directory
 from foundry_mcp.tools.unified.router import (
@@ -55,6 +57,20 @@ def _extract_plan_name(plan_path: str) -> str:
     return Path(plan_path).stem
 
 
+def _find_config_file(start_path: Path) -> Optional[Path]:
+    """Find foundry-mcp.toml by walking up from start_path."""
+    current = start_path if start_path.is_dir() else start_path.parent
+    for _ in range(10):  # Limit depth to prevent infinite loops
+        config_file = current / "foundry-mcp.toml"
+        if config_file.exists():
+            return config_file
+        parent = current.parent
+        if parent == current:  # Reached root
+            break
+        current = parent
+    return None
+
+
 def _parse_review_summary(content: str) -> dict:
     """Parse review markdown to extract section counts."""
 
@@ -323,7 +339,10 @@ def perform_plan_review(
     template_id = REVIEW_TYPE_TO_TEMPLATE[review_type]
 
     try:
-        orchestrator = ConsultationOrchestrator()
+        # Load consultation config from workspace to get provider priority list
+        config_file = _find_config_file(plan_file)
+        consultation_config = load_consultation_config(config_file=config_file)
+        orchestrator = ConsultationOrchestrator(config=consultation_config)
         request = ConsultationRequest(
             workflow=ConsultationWorkflow.MARKDOWN_PLAN_REVIEW,
             prompt_id=template_id,

foundry_mcp/tools/unified/provider.py

@@ -11,7 +11,6 @@ from mcp.server.fastmcp import FastMCP
 
 from foundry_mcp.config import ServerConfig
 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.llm_provider import RateLimitError
 from foundry_mcp.core.naming import canonical_tool
 from foundry_mcp.core.observability import get_metrics, mcp_tool
@@ -42,19 +41,6 @@ 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="provider_tools",
-            description="LLM provider management and execution tools",
-            state=FlagState.BETA,
-            default_enabled=True,
-        )
-    )
-except ValueError:
-    # Flag already registered
-    pass
 
 _ACTION_SUMMARY = {
     "list": "List registered providers with optional unavailable entries",
@@ -92,22 +78,6 @@ def _validation_error(
     )
 
 
-def _feature_flag_blocked(request_id: str) -> Optional[dict]:
-    if _flag_service.is_enabled("provider_tools"):
-        return None
-
-    return asdict(
-        error_response(
-            "Provider tools are disabled by feature flag",
-            error_code=ErrorCode.FEATURE_DISABLED,
-            error_type=ErrorType.FEATURE_FLAG,
-            data={"feature": "provider_tools"},
-            remediation="Enable the 'provider_tools' feature flag to call provider actions.",
-            request_id=request_id,
-        )
-    )
-
-
 def _handle_list(
     *,
     config: ServerConfig,  # noqa: ARG001 - reserved for future hooks
@@ -115,9 +85,6 @@ def _handle_list(
     **_: Any,
 ) -> dict:
     request_id = _request_id()
-    blocked = _feature_flag_blocked(request_id)
-    if blocked:
-        return blocked
 
     include = include_unavailable if isinstance(include_unavailable, bool) else False
     if include_unavailable is not None and not isinstance(include_unavailable, bool):
@@ -182,9 +149,6 @@ def _handle_status(
     **_: Any,
 ) -> dict:
     request_id = _request_id()
-    blocked = _feature_flag_blocked(request_id)
-    if blocked:
-        return blocked
 
     if not isinstance(provider_id, str) or not provider_id.strip():
         return _validation_error(
@@ -288,10 +252,6 @@ def _handle_execute(
     **_: Any,
 ) -> dict:
     request_id = _request_id()
-    blocked = _feature_flag_blocked(request_id)
-    if blocked:
-        return blocked
-
     action = "execute"
 
     if not isinstance(provider_id, str) or not provider_id.strip():