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

foundry_mcp/tools/unified/review.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import json
 import logging
 import time
+from datetime import datetime
 from dataclasses import asdict
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -19,9 +20,14 @@ from foundry_mcp.config import ServerConfig
 from foundry_mcp.core.ai_consultation import (
     ConsultationOrchestrator,
     ConsultationRequest,
+    ConsultationResult,
     ConsultationWorkflow,
     ConsensusResult,
 )
+from foundry_mcp.core.prompts.fidelity_review import (
+    FIDELITY_SYNTHESIZED_RESPONSE_SCHEMA,
+)
+from foundry_mcp.core.llm_config import get_consultation_config, 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 get_provider_statuses
@@ -82,7 +88,11 @@ def _parse_json_content(content: str) -> Optional[dict]:
 
 def _handle_spec_review(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
     spec_id = payload.get("spec_id")
-    review_type = payload.get("review_type", "quick")
+    # Get default review_type from consultation config (used when not provided or None)
+    consultation_config = get_consultation_config()
+    workflow_config = consultation_config.get_workflow_config("plan_review")
+    default_review_type = workflow_config.default_review_type
+    review_type = payload.get("review_type") or default_review_type
 
     if not isinstance(spec_id, str) or not spec_id.strip():
         return asdict(
@@ -360,6 +370,159 @@ def _handle_parse_feedback(*, config: ServerConfig, payload: Dict[str, Any]) ->
     )
 
 
+def _format_fidelity_markdown(
+    parsed: Dict[str, Any],
+    spec_id: str,
+    spec_title: str,
+    scope: str,
+    task_id: Optional[str] = None,
+    phase_id: Optional[str] = None,
+    provider_id: Optional[str] = None,
+) -> str:
+    """Format fidelity review JSON as human-readable markdown."""
+    # Build scope detail
+    scope_detail = scope
+    if task_id:
+        scope_detail += f" (task: {task_id})"
+    elif phase_id:
+        scope_detail += f" (phase: {phase_id})"
+
+    lines = [
+        f"# Fidelity Review: {spec_title}",
+        "",
+        f"**Spec ID:** {spec_id}",
+        f"**Scope:** {scope_detail}",
+        f"**Verdict:** {parsed.get('verdict', 'unknown')}",
+        f"**Date:** {datetime.now().isoformat()}",
+    ]
+    if provider_id:
+        lines.append(f"**Provider:** {provider_id}")
+    lines.append("")
+
+    # Summary section
+    if parsed.get("summary"):
+        lines.extend(["## Summary", "", parsed["summary"], ""])
+
+    # Requirement Alignment
+    req_align = parsed.get("requirement_alignment", {})
+    if req_align:
+        lines.extend([
+            "## Requirement Alignment",
+            f"**Status:** {req_align.get('answer', 'unknown')}",
+            "",
+            req_align.get("details", ""),
+            "",
+        ])
+
+    # Success Criteria
+    success = parsed.get("success_criteria", {})
+    if success:
+        lines.extend([
+            "## Success Criteria",
+            f"**Status:** {success.get('met', 'unknown')}",
+            "",
+            success.get("details", ""),
+            "",
+        ])
+
+    # Deviations
+    deviations = parsed.get("deviations", [])
+    if deviations:
+        lines.extend(["## Deviations", ""])
+        for dev in deviations:
+            severity = dev.get("severity", "unknown")
+            description = dev.get("description", "")
+            justification = dev.get("justification", "")
+            lines.append(f"- **[{severity.upper()}]** {description}")
+            if justification:
+                lines.append(f"  - Justification: {justification}")
+        lines.append("")
+
+    # Test Coverage
+    test_cov = parsed.get("test_coverage", {})
+    if test_cov:
+        lines.extend([
+            "## Test Coverage",
+            f"**Status:** {test_cov.get('status', 'unknown')}",
+            "",
+            test_cov.get("details", ""),
+            "",
+        ])
+
+    # Code Quality
+    code_quality = parsed.get("code_quality", {})
+    if code_quality:
+        lines.extend(["## Code Quality", ""])
+        if code_quality.get("details"):
+            lines.append(code_quality["details"])
+            lines.append("")
+        for issue in code_quality.get("issues", []):
+            lines.append(f"- {issue}")
+        lines.append("")
+
+    # Documentation
+    doc = parsed.get("documentation", {})
+    if doc:
+        lines.extend([
+            "## Documentation",
+            f"**Status:** {doc.get('status', 'unknown')}",
+            "",
+            doc.get("details", ""),
+            "",
+        ])
+
+    # Issues
+    issues = parsed.get("issues", [])
+    if issues:
+        lines.extend(["## Issues", ""])
+        for issue in issues:
+            lines.append(f"- {issue}")
+        lines.append("")
+
+    # Recommendations
+    recommendations = parsed.get("recommendations", [])
+    if recommendations:
+        lines.extend(["## Recommendations", ""])
+        for rec in recommendations:
+            lines.append(f"- {rec}")
+        lines.append("")
+
+    # Verdict consensus (if synthesized)
+    verdict_consensus = parsed.get("verdict_consensus", {})
+    if verdict_consensus:
+        lines.extend(["## Verdict Consensus", ""])
+        votes = verdict_consensus.get("votes", {})
+        for verdict_type, models in votes.items():
+            if models:
+                lines.append(f"- **{verdict_type}:** {', '.join(models)}")
+        agreement = verdict_consensus.get("agreement_level", "")
+        if agreement:
+            lines.append(f"\n**Agreement Level:** {agreement}")
+        notes = verdict_consensus.get("notes", "")
+        if notes:
+            lines.extend(["", notes])
+        lines.append("")
+
+    # Synthesis metadata
+    synth_meta = parsed.get("synthesis_metadata", {})
+    if synth_meta:
+        lines.extend(["## Synthesis Metadata", ""])
+        if synth_meta.get("models_consulted"):
+            lines.append(f"- Models consulted: {', '.join(synth_meta['models_consulted'])}")
+        if synth_meta.get("models_succeeded"):
+            lines.append(f"- Models succeeded: {', '.join(synth_meta['models_succeeded'])}")
+        if synth_meta.get("synthesis_provider"):
+            lines.append(f"- Synthesis provider: {synth_meta['synthesis_provider']}")
+        lines.append("")
+
+    lines.extend([
+        "---",
+        "*Generated by Foundry MCP Fidelity Review*",
+    ])
+
+    return "\n".join(lines)
+
+
 def _handle_fidelity(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
     """Best-effort fidelity review.
 
@@ -512,9 +675,25 @@ def _handle_fidelity(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
 
     scope = "task" if task_id else ("phase" if phase_id else "spec")
 
+    # Setup fidelity reviews directory and file naming
+    fidelity_reviews_dir = Path(specs_dir) / ".fidelity-reviews"
+    base_name = f"{spec_id}-{scope}"
+    if task_id:
+        base_name += f"-{task_id}"
+    elif phase_id:
+        base_name += f"-{phase_id}"
+    provider_review_paths: List[Dict[str, Any]] = []
+    review_path: Optional[str] = None
+
     spec_requirements = _build_spec_requirements(spec_data, task_id, phase_id)
     implementation_artifacts = _build_implementation_artifacts(
-        spec_data, task_id, phase_id, files, incremental, base_branch
+        spec_data,
+        task_id,
+        phase_id,
+        files,
+        incremental,
+        base_branch,
+        workspace_root=ws_path,
     )
     test_results = (
         _build_test_results(spec_data, task_id, phase_id) if include_tests else ""
@@ -524,7 +703,10 @@ def _handle_fidelity(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
     preferred_providers = ai_tools if isinstance(ai_tools, list) else []
     first_provider = preferred_providers[0] if preferred_providers else None
 
-    orchestrator = ConsultationOrchestrator()
+    # Load consultation config from workspace path to get provider priority list
+    config_file = ws_path / "foundry-mcp.toml"
+    consultation_config = load_consultation_config(config_file=config_file)
+    orchestrator = ConsultationOrchestrator(config=consultation_config)
     if not orchestrator.is_available(provider_id=first_provider):
         return asdict(
             error_response(
@@ -555,27 +737,202 @@ def _handle_fidelity(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
 
     result = orchestrator.consult(request, use_cache=True)
     is_consensus = isinstance(result, ConsensusResult)
-    content = result.primary_content if is_consensus else result.content
+    synthesis_performed = False
+    synthesis_error = None
+    successful_providers: List[str] = []
+    failed_providers: List[Dict[str, Any]] = []
+
+    if is_consensus:
+        # Extract 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]
+
+        if len(successful_responses) >= 2:
+            # Multi-model mode: run synthesis to consolidate reviews
+            model_reviews_json = ""
+            for response in successful_responses:
+                model_reviews_json += (
+                    f"\n---\n## Review by {response.provider_id}\n\n"
+                    f"```json\n{response.content}\n```\n"
+                )
+
+            # Write individual provider review files
+            try:
+                fidelity_reviews_dir.mkdir(parents=True, exist_ok=True)
+                for response in successful_responses:
+                    provider_parsed = _parse_json_content(response.content)
+                    provider_file = fidelity_reviews_dir / f"{base_name}-{response.provider_id}.md"
+                    if provider_parsed:
+                        provider_md = _format_fidelity_markdown(
+                            provider_parsed,
+                            spec_id,
+                            spec_data.get("title", spec_id),
+                            scope,
+                            task_id=task_id,
+                            phase_id=phase_id,
+                            provider_id=response.provider_id,
+                        )
+                        provider_file.write_text(provider_md, encoding="utf-8")
+                        provider_review_paths.append({
+                            "provider_id": response.provider_id,
+                            "path": str(provider_file),
+                        })
+                    else:
+                        # JSON parsing failed - write raw content as fallback
+                        logger.warning(
+                            "Provider %s returned non-JSON content, writing raw response",
+                            response.provider_id,
+                        )
+                        raw_md = (
+                            f"# Fidelity Review (Raw): {spec_id}\n\n"
+                            f"**Provider:** {response.provider_id}\n"
+                            f"**Note:** Response could not be parsed as JSON\n\n"
+                            f"## Raw Response\n\n```\n{response.content}\n```\n"
+                        )
+                        provider_file.write_text(raw_md, encoding="utf-8")
+                        provider_review_paths.append({
+                            "provider_id": response.provider_id,
+                            "path": str(provider_file),
+                            "parse_error": True,
+                        })
+            except Exception as e:
+                logger.warning("Failed to write provider review files: %s", e)
+
+            logger.info(
+                "Running fidelity synthesis for %d provider reviews: %s",
+                len(successful_responses),
+                successful_providers,
+            )
+
+            synthesis_request = ConsultationRequest(
+                workflow=ConsultationWorkflow.FIDELITY_REVIEW,
+                prompt_id="FIDELITY_SYNTHESIS_PROMPT_V1",
+                context={
+                    "spec_id": spec_id,
+                    "spec_title": spec_data.get("title", spec_id),
+                    "review_scope": scope,
+                    "num_models": len(successful_responses),
+                    "model_reviews": model_reviews_json,
+                    "response_schema": FIDELITY_SYNTHESIZED_RESPONSE_SCHEMA,
+                },
+                provider_id=successful_providers[0],
+                model=model,
+            )
+
+            try:
+                synthesis_result = orchestrator.consult(synthesis_request, use_cache=True)
+            except Exception as e:
+                logger.error("Fidelity synthesis call crashed: %s", e, exc_info=True)
+                synthesis_result = None
+
+            # Handle both ConsultationResult and ConsensusResult from synthesis
+            synthesis_success = False
+            synthesis_content = None
+            if synthesis_result:
+                if isinstance(synthesis_result, ConsultationResult) and synthesis_result.success:
+                    synthesis_content = synthesis_result.content
+                    synthesis_success = bool(synthesis_content and synthesis_content.strip())
+                elif isinstance(synthesis_result, ConsensusResult) and synthesis_result.success:
+                    synthesis_content = synthesis_result.primary_content
+                    synthesis_success = bool(synthesis_content and synthesis_content.strip())
+
+            if synthesis_success and synthesis_content:
+                content = synthesis_content
+                synthesis_performed = True
+            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(
+                    "Fidelity synthesis call failed (%s), falling back to first provider's content",
+                    error_detail,
+                )
+                content = result.primary_content
+                synthesis_error = error_detail
+        else:
+            # Single successful provider - use its content directly (no synthesis needed)
+            content = result.primary_content
+    else:
+        content = result.content
 
     parsed = _parse_json_content(content)
     verdict = parsed.get("verdict") if parsed else "unknown"
 
+    # Write main fidelity review file
+    if parsed:
+        try:
+            fidelity_reviews_dir.mkdir(parents=True, exist_ok=True)
+            main_md = _format_fidelity_markdown(
+                parsed,
+                spec_id,
+                spec_data.get("title", spec_id),
+                scope,
+                task_id=task_id,
+                phase_id=phase_id,
+            )
+            review_file = fidelity_reviews_dir / f"{base_name}.md"
+            review_file.write_text(main_md, encoding="utf-8")
+            review_path = str(review_file)
+        except Exception as e:
+            logger.warning("Failed to write main fidelity review file: %s", e)
+
     duration_ms = (time.perf_counter() - start_time) * 1000
 
+    # Build consensus info with synthesis details
+    consensus_info: Dict[str, Any] = {
+        "mode": "multi_model" if is_consensus else "single_model",
+        "threshold": consensus_threshold,
+        "provider_id": getattr(result, "provider_id", None),
+        "model_used": getattr(result, "model_used", None),
+        "synthesis_performed": synthesis_performed,
+    }
+
+    if is_consensus:
+        consensus_info["successful_providers"] = successful_providers
+        consensus_info["failed_providers"] = failed_providers
+        if synthesis_error:
+            consensus_info["synthesis_error"] = synthesis_error
+
+    # Include additional synthesized fields if available
+    response_data: Dict[str, Any] = {
+        "spec_id": spec_id,
+        "title": spec_data.get("title", spec_id),
+        "scope": scope,
+        "verdict": verdict,
+        "deviations": parsed.get("deviations") if parsed else [],
+        "recommendations": parsed.get("recommendations") if parsed else [],
+        "consensus": consensus_info,
+    }
+
+    # Add file paths if reviews were written
+    if review_path:
+        response_data["review_path"] = review_path
+    if provider_review_paths:
+        response_data["provider_reviews"] = provider_review_paths
+
+    # Add synthesis-specific fields if synthesis was performed
+    if synthesis_performed and parsed:
+        if "verdict_consensus" in parsed:
+            response_data["verdict_consensus"] = parsed["verdict_consensus"]
+        if "synthesis_metadata" in parsed:
+            response_data["synthesis_metadata"] = parsed["synthesis_metadata"]
+
     return asdict(
         success_response(
-            spec_id=spec_id,
-            title=spec_data.get("title", spec_id),
-            scope=scope,
-            verdict=verdict,
-            deviations=(parsed.get("deviations") if parsed else []),
-            recommendations=(parsed.get("recommendations") if parsed else []),
-            consensus={
-                "mode": "multi_model" if is_consensus else "single_model",
-                "threshold": consensus_threshold,
-                "provider_id": getattr(result, "provider_id", None),
-                "model_used": getattr(result, "model_used", None),
-            },
+            **response_data,
             telemetry={"duration_ms": round(duration_ms, 2)},
         )
     )
@@ -633,7 +990,7 @@ def register_unified_review_tool(mcp: FastMCP, config: ServerConfig) -> None:
     def review(
         action: str,
         spec_id: Optional[str] = None,
-        review_type: str = "quick",
+        review_type: Optional[str] = None,
         tools: Optional[str] = None,
         model: Optional[str] = None,
         ai_provider: Optional[str] = None,

foundry_mcp/tools/unified/review_helpers.py

@@ -193,6 +193,7 @@ def _run_ai_review(
             ConsultationRequest,
             ConsultationWorkflow,
         )
+        from foundry_mcp.core.llm_config import load_consultation_config
     except ImportError:
         return asdict(
             error_response(
@@ -203,7 +204,21 @@ def _run_ai_review(
             )
         )
 
-    orchestrator = ConsultationOrchestrator(default_timeout=ai_timeout)
+    # Load consultation config from workspace (fixes config discovery issue)
+    # Derive workspace from specs_dir - check parent directories for config
+    config_file = None
+    if specs_dir:
+        ws_path = specs_dir.parent if specs_dir.name == "specs" else specs_dir
+        for _ in range(5):  # Search up to 5 levels for foundry-mcp.toml
+            candidate = ws_path / "foundry-mcp.toml"
+            if candidate.exists():
+                config_file = candidate
+                break
+            if ws_path.parent == ws_path:  # Reached root
+                break
+            ws_path = ws_path.parent
+    consultation_config = load_consultation_config(config_file=config_file)
+    orchestrator = ConsultationOrchestrator(config=consultation_config, default_timeout=ai_timeout)
 
     if not orchestrator.is_available(provider_id=ai_provider):
         return asdict(

foundry_mcp/tools/unified/server.py

@@ -18,7 +18,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.discovery import get_capabilities, get_tool_registry
-from foundry_mcp.core.feature_flags import get_flag_service
 from foundry_mcp.core.naming import canonical_tool
 from foundry_mcp.core.observability import (
     get_metrics,
@@ -256,26 +255,15 @@ def _handle_tools(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
 
     start_time = time.perf_counter()
 
-    categories_list: list[str]
-    flag_service = get_flag_service()
-    if flag_service.is_enabled("unified_manifest"):
-        all_tools = _build_unified_manifest_tools()
-        if category:
-            all_tools = [tool for tool in all_tools if tool.get("category") == category]
-        if tag:
-            all_tools = [tool for tool in all_tools if tag in (tool.get("tags") or [])]
-        categories_list = sorted(
-            {tool.get("category", "general") for tool in all_tools}
-        )
-    else:
-        registry = get_tool_registry()
-        all_tools = registry.list_tools(
-            category=category,
-            tag=tag,
-            include_deprecated=include_deprecated,
-        )
-        categories = registry.list_categories()
-        categories_list = [c["name"] for c in categories]
+    # Always use unified manifest (feature flags removed)
+    all_tools = _build_unified_manifest_tools()
+    if category:
+        all_tools = [tool for tool in all_tools if tool.get("category") == category]
+    if tag:
+        all_tools = [tool for tool in all_tools if tag in (tool.get("tags") or [])]
+    categories_list = sorted(
+        {tool.get("category", "general") for tool in all_tools}
+    )
 
     start_idx = 0
     if cursor:
@@ -360,9 +348,6 @@ def _handle_tools(*, config: ServerConfig, payload: Dict[str, Any]) -> dict:
             tokens=manifest_tokens,
             tool_count=len(all_tools),
         )
-        exporter.record_feature_flag_state(
-            "unified_manifest", flag_service.is_enabled("unified_manifest")
-        )
 
     response["meta"]["request_id"] = request_id
     return response