forge-dev 0.1.0__py3-none-any.whl

mcp_server/server.py

@@ -0,0 +1,1086 @@
+"""Forge MCP Server — exposes Forge capabilities to any MCP-compatible editor.
+
+This server makes Forge accessible from Cursor, Copilot, Windsurf,
+Claude Code, or any editor that supports MCP.
+
+Tools exposed:
+- forge_init: Initialize a project
+- forge_intake: Process a requirement
+- forge_context: Get/set project context
+- forge_status: Project status
+- forge_audit: Run audit agents
+- forge_assess: Maturity assessment
+- forge_journal: Add journal entries
+- forge_standards: Manage standards
+- forge_coherence_check: Validate changes
+- forge_mcps: MCP registry
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel, ConfigDict, Field
+
+# ── Server Init ────────────────────────────────────────────────────────────
+
+mcp = FastMCP("forge_mcp")
+
+
+# ── Input Models ───────────────────────────────────────────────────────────
+
+class ForgeInitInput(BaseModel):
+    """Input for initializing Forge in a project directory."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    path: str = Field(
+        default=".",
+        description="Path to the project directory. Defaults to current directory.",
+    )
+    name: Optional[str] = Field(
+        default=None,
+        description="Project name. Defaults to directory name.",
+    )
+    backend: Optional[str] = Field(
+        default=None,
+        description=(
+            "Backend framework override. Options: python/fastapi, python/django, "
+            "node/express, node/fastify, node/nestjs"
+        ),
+    )
+    project_type: Optional[str] = Field(
+        default=None,
+        description="Project type: saas, api, internal-tool, library, cli, microservice",
+    )
+    description: Optional[str] = Field(
+        default=None,
+        description="One-line project description.",
+    )
+    regulatory: Optional[list[str]] = Field(
+        default=None,
+        description="Regulatory requirements: hipaa, ferpa, gdpr, soc2, pci-dss",
+    )
+    ai_enabled: Optional[bool] = Field(
+        default=None,
+        description="Whether the project uses AI capabilities internally.",
+    )
+
+
+class ForgeIntakeInput(BaseModel):
+    """Input for processing a requirement document."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    content: str = Field(
+        ...,
+        description=(
+            "The requirement content. Can be a PRD, user story, epic, "
+            "feature request, or any description of what to build."
+        ),
+        min_length=10,
+    )
+    path: str = Field(
+        default=".",
+        description="Path to the project directory.",
+    )
+
+
+class ForgeJournalInput(BaseModel):
+    """Input for adding a journal entry."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    entry: str = Field(
+        ...,
+        description=(
+            "The journal entry. Record learnings, workarounds, nuances, "
+            "or any project-specific context that agents should know."
+        ),
+        min_length=5,
+    )
+    path: str = Field(
+        default=".",
+        description="Path to the project directory.",
+    )
+
+
+class ForgeStandardInput(BaseModel):
+    """Input for adding a new standard."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    name: str = Field(..., description="Standard name", min_length=2, max_length=100)
+    area: str = Field(
+        ...,
+        description="Area this standard governs (e.g., security, api-design, testing, frontend)",
+    )
+    description: str = Field(
+        ...,
+        description="What this standard requires — be specific and actionable.",
+    )
+    enforcement: str = Field(
+        default="required",
+        description="Enforcement level: required, recommended, optional",
+    )
+    rules: Optional[list[str]] = Field(
+        default=None,
+        description="Specific rules this standard enforces.",
+    )
+
+
+class ForgePathInput(BaseModel):
+    """Simple input with just a project path."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    path: str = Field(
+        default=".",
+        description="Path to the project directory.",
+    )
+
+
+class ForgeContextOverrideInput(BaseModel):
+    """Input for overriding specific context values."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    path: str = Field(default=".", description="Path to the project directory.")
+    overrides: dict = Field(
+        ...,
+        description=(
+            "Key-value pairs to override in the project context. "
+            "Example: {\"backend\": \"node/fastify\", \"auth\": \"auth0\"}"
+        ),
+    )
+
+
+# ── Tools ──────────────────────────────────────────────────────────────────
+
+@mcp.tool(
+    name="forge_init",
+    annotations={
+        "title": "Initialize Forge Project",
+        "readOnlyHint": False,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_init(params: ForgeInitInput) -> str:
+    """Initialize Forge in a project directory.
+
+    Detects the current state of the directory (empty, has docs, has code,
+    already initialized) and sets up the .forge/ directory with context,
+    journal, and configuration.
+
+    Returns the project detection results, resolved context, and next steps.
+    """
+    from forge_core.detector import detect_project
+    from forge_core.phases.context import resolve_context, save_context
+    from forge_core.registry import ensure_registry, load_user_config, record_project
+
+    project_path = Path(params.path).resolve()
+
+    ensure_registry()
+    user_config = load_user_config()
+    detection = detect_project(project_path)
+
+    if detection.has_forge:
+        from forge_core.phases.context import load_context
+        context = load_context(project_path)
+        return json.dumps({
+            "status": "already_initialized",
+            "project": context.name if context else project_path.name,
+            "message": "Project already has Forge. Use forge_status, forge_assess, or forge_audit.",
+            "detection": detection.summary(),
+        }, indent=2)
+
+    # Build overrides from params
+    overrides: dict = {}
+    if params.project_type:
+        overrides["type"] = params.project_type
+    if params.description:
+        overrides["description"] = params.description
+    if params.regulatory:
+        overrides["regulatory"] = params.regulatory
+    if params.backend:
+        overrides["backend"] = params.backend
+    if params.ai_enabled is not None:
+        overrides["ai"] = {"enabled": params.ai_enabled}
+
+    context = resolve_context(
+        detection, user_config,
+        project_name=params.name,
+        overrides=overrides,
+    )
+
+    context_path = save_context(context, project_path)
+
+    # Create journal
+    journal_path = project_path / ".forge" / "journal.md"
+    if not journal_path.exists():
+        journal_path.write_text(
+            f"# {context.name} — Forge Journal\n\n"
+            "Record project-specific learnings, workarounds, and nuances here.\n\n"
+            "## Entries\n\n"
+        )
+
+    record_project(
+        context.name,
+        str(project_path),
+        {"type": context.type.value, "backend": context.backend.value, "cloud": context.cloud.value},
+    )
+
+    # Determine what questions to ask if info is missing
+    needs_input = []
+    if not params.description and detection.is_empty:
+        needs_input.append("description: What does this project do?")
+    if user_config.backend is None and not params.backend:
+        needs_input.append("backend: Which backend framework? (python/fastapi, node/express, etc.)")
+
+    result = {
+        "status": "initialized",
+        "project": context.name,
+        "detection": {
+            "state": detection.state.value,
+            "code_files": len(detection.code_files),
+            "doc_files": len(detection.doc_files),
+            "detected_stack": detection.detected_stack,
+        },
+        "context": {
+            "backend": context.backend.value,
+            "frontend": context.frontend.value,
+            "cloud": context.cloud.value,
+            "database": context.database.value,
+            "auth": context.auth.value,
+            "ai_enabled": context.ai.enabled,
+            "type": context.type.value,
+        },
+        "files_created": [str(context_path), str(journal_path)],
+        "next_steps": [
+            "forge_intake — process a requirement document",
+            "forge_plan — generate implementation plan",
+        ],
+    }
+
+    if needs_input:
+        result["needs_input"] = needs_input
+        result["message"] = (
+            "Project initialized with defaults. Consider providing: "
+            + "; ".join(needs_input)
+        )
+
+    return json.dumps(result, indent=2)
+
+
+@mcp.tool(
+    name="forge_intake",
+    annotations={
+        "title": "Process Requirement into Forge Brief",
+        "readOnlyHint": False,
+        "destructiveHint": False,
+        "idempotentHint": False,
+        "openWorldHint": False,
+    },
+)
+async def forge_intake(params: ForgeIntakeInput) -> str:
+    """Analyze a requirement and produce a structured Forge Brief.
+
+    Accepts any kind of requirement: PRD, user story, epic, feature request,
+    or informal description. Classifies it, detects gaps, and produces
+    an AI-optimized implementation order.
+
+    The output includes a prompt ready to send to an LLM for full analysis,
+    plus the basic classification results.
+    """
+    from forge_core.phases.intake import (
+        build_intake_prompt,
+        classify_requirement,
+    )
+
+    project_path = Path(params.path).resolve()
+    forge_dir = project_path / ".forge"
+
+    if not forge_dir.exists():
+        return json.dumps({
+            "error": "No Forge project found. Run forge_init first.",
+        })
+
+    req_type = classify_requirement(params.content)
+    prompt = build_intake_prompt(params.content, req_type)
+
+    # Save prompt for processing
+    prompt_path = forge_dir / "intake_prompt.md"
+    prompt_path.write_text(prompt)
+
+    return json.dumps({
+        "status": "intake_ready",
+        "requirement_type": req_type.value,
+        "content_length": len(params.content),
+        "prompt_saved_to": str(prompt_path),
+        "llm_prompt": prompt,
+        "instruction": (
+            "Send the llm_prompt to Claude or another LLM to generate the full brief. "
+            "The response should be a JSON object matching the ForgeBrief schema. "
+            "Save the result to .forge/brief.yaml"
+        ),
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_status",
+    annotations={
+        "title": "Get Forge Project Status",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_status(params: ForgePathInput) -> str:
+    """Get the current status of a Forge project.
+
+    Shows: context, brief, plan, journal, and audit state.
+    Also shows the resolved stack, cloud, and auth configuration.
+    """
+    from forge_core.phases.context import load_context
+    from forge_core.phases.intake import load_brief
+    from forge_core.registry import get_forge_version
+
+    project_path = Path(params.path).resolve()
+    forge_dir = project_path / ".forge"
+
+    if not forge_dir.exists():
+        return json.dumps({"error": "No Forge project found. Run forge_init first."})
+
+    context = load_context(project_path)
+    brief = load_brief(project_path)
+    version = get_forge_version()
+
+    result = {
+        "forge_version": version,
+        "project": context.name if context else project_path.name,
+        "components": {
+            "context": "ready" if context else "missing",
+            "brief": "ready" if brief else "not_started",
+            "plan": "ready" if (forge_dir / "plan.yaml").exists() else "not_started",
+            "journal": "ready" if (forge_dir / "journal.md").exists() else "missing",
+        },
+    }
+
+    if context:
+        result["stack"] = {
+            "backend": context.backend.value,
+            "frontend": context.frontend.value,
+            "cloud": context.cloud.value,
+            "database": context.database.value,
+            "auth": context.auth.value,
+            "ai_enabled": context.ai.enabled,
+            "type": context.type.value,
+            "regulatory": [r.value for r in context.regulatory],
+        }
+
+    if brief:
+        result["brief_summary"] = {
+            "source_type": brief.source_type.value,
+            "completeness": brief.completeness_score,
+            "features": len(brief.features),
+            "gaps": len(brief.gaps),
+            "mvp_defined": brief.mvp_defined,
+        }
+
+    return json.dumps(result, indent=2)
+
+
+@mcp.tool(
+    name="forge_journal",
+    annotations={
+        "title": "Add Project Journal Entry",
+        "readOnlyHint": False,
+        "destructiveHint": False,
+        "idempotentHint": False,
+        "openWorldHint": False,
+    },
+)
+async def forge_journal(params: ForgeJournalInput) -> str:
+    """Add a learning, workaround, or nuance to the project journal.
+
+    The journal captures project-specific context that doesn't fit in
+    standards or patterns. Things like:
+    - "To access Azure DB, install pg in temp and use tunnel"
+    - "The legacy API returns dates in MM/DD/YYYY not ISO"
+    - "Rate limit on external API is 100/min, batch accordingly"
+
+    Forge agents read the journal for project-specific awareness.
+    """
+    from datetime import datetime, timezone
+
+    project_path = Path(params.path).resolve()
+    journal_path = project_path / ".forge" / "journal.md"
+
+    if not journal_path.exists():
+        return json.dumps({"error": "No Forge project found. Run forge_init first."})
+
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+    with open(journal_path, "a") as f:
+        f.write(f"\n### {timestamp}\n{params.entry}\n")
+
+    return json.dumps({
+        "status": "entry_added",
+        "timestamp": timestamp,
+        "entry": params.entry,
+    })
+
+
+@mcp.tool(
+    name="forge_standards_add",
+    annotations={
+        "title": "Add a New Standard",
+        "readOnlyHint": False,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_standards_add(params: ForgeStandardInput) -> str:
+    """Add a new standard to the Forge registry.
+
+    Before adding, runs a coherence check against existing standards
+    to detect conflicts, overlaps, or philosophy changes.
+
+    Standards are stored globally in ~/.forge/user/standards/ and
+    apply to all future projects. Existing projects can be re-assessed
+    with forge_assess to check compliance.
+    """
+    import yaml
+
+    from forge_core.phases.coherence import check_new_standard
+    from forge_core.registry import USER_DIR, load_standards, version_workflow
+
+    existing = load_standards()
+
+    new_standard = {
+        "name": params.name,
+        "area": params.area,
+        "description": params.description,
+        "enforcement": params.enforcement,
+    }
+    if params.rules:
+        new_standard["rules"] = params.rules
+
+    report = check_new_standard(new_standard, existing)
+
+    if not report.passed:
+        return json.dumps({
+            "status": "blocked",
+            "message": "Coherence check failed — resolve errors before adding.",
+            "issues": [
+                {
+                    "severity": i.severity,
+                    "category": i.category,
+                    "description": i.description,
+                    "suggestion": i.suggestion,
+                }
+                for i in report.issues
+            ],
+        }, indent=2)
+
+    # Save
+    standards_dir = USER_DIR / "standards"
+    standards_dir.mkdir(parents=True, exist_ok=True)
+    std_path = standards_dir / f"{params.name.lower().replace(' ', '-')}.yaml"
+    with open(std_path, "w") as f:
+        yaml.dump(new_standard, f, default_flow_style=False)
+
+    version_id = version_workflow(f"Added standard: {params.name}")
+
+    result = {
+        "status": "added",
+        "standard": params.name,
+        "area": params.area,
+        "file": str(std_path),
+        "workflow_version": version_id,
+    }
+
+    if report.issues:
+        result["warnings"] = [
+            {
+                "severity": i.severity,
+                "category": i.category,
+                "description": i.description,
+                "suggestion": i.suggestion,
+            }
+            for i in report.issues
+        ]
+
+    return json.dumps(result, indent=2)
+
+
+@mcp.tool(
+    name="forge_standards_list",
+    annotations={
+        "title": "List All Standards",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_standards_list(params: ForgePathInput) -> str:
+    """List all active Forge standards (core + user).
+
+    Shows standards from both the upstream core and user customizations.
+    """
+    from forge_core.registry import load_standards
+
+    standards = load_standards()
+
+    return json.dumps({
+        "total": len(standards),
+        "standards": [
+            {
+                "name": s.get("name", "unnamed"),
+                "area": s.get("area", s.get("category", "general")),
+                "description": s.get("description", ""),
+                "source": s.get("_source", "unknown"),
+                "enforcement": s.get("enforcement", "required"),
+            }
+            for s in standards
+        ],
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_coherence_check",
+    annotations={
+        "title": "Run Coherence Check",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_coherence_check(params: ForgePathInput) -> str:
+    """Run a full coherence check on all standards and workflow configuration.
+
+    Detects: conflicts between standards, overlapping areas, enforcement
+    mismatches, and potential race conditions between agents.
+    """
+    from forge_core.phases.coherence import check_standards_coherence
+    from forge_core.registry import load_standards
+
+    standards = load_standards()
+    report = check_standards_coherence(standards)
+
+    return json.dumps({
+        "passed": report.passed,
+        "total_standards": len(standards),
+        "issues": [
+            {
+                "severity": i.severity,
+                "category": i.category,
+                "description": i.description,
+                "suggestion": i.suggestion,
+            }
+            for i in report.issues
+        ],
+        "summary": report.summary(),
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_mcps_list",
+    annotations={
+        "title": "List MCP Registry",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_mcps_list(params: ForgePathInput) -> str:
+    """List all MCPs in the Forge registry.
+
+    Shows configured MCP servers with their auto-suggest conditions.
+    These MCPs are recommended/configured automatically when scaffolding
+    new projects.
+    """
+    from forge_core.registry import load_mcps
+
+    mcps = load_mcps()
+
+    return json.dumps({
+        "total": len(mcps),
+        "mcps": [
+            {
+                "name": m.name,
+                "description": m.description,
+                "url": m.url,
+                "transport": m.transport,
+                "auto_suggest": m.auto_suggest,
+                "conditions": m.conditions,
+            }
+            for m in mcps
+        ],
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_context_get",
+    annotations={
+        "title": "Get Project Context",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_context_get(params: ForgePathInput) -> str:
+    """Get the full project context including stack, infra, and all decisions.
+
+    Returns the complete .forge/context.yaml as structured data.
+    """
+    from forge_core.phases.context import load_context
+
+    project_path = Path(params.path).resolve()
+    context = load_context(project_path)
+
+    if not context:
+        return json.dumps({"error": "No context found. Run forge_init first."})
+
+    return json.dumps(context.model_dump(mode="json"), indent=2)
+
+
+@mcp.tool(
+    name="forge_context_override",
+    annotations={
+        "title": "Override Project Context Values",
+        "readOnlyHint": False,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_context_override(params: ForgeContextOverrideInput) -> str:
+    """Override specific values in the project context.
+
+    Use this to change stack decisions, auth patterns, or any other
+    configuration without re-running forge_init.
+    """
+    import yaml
+
+    from forge_core.phases.context import load_context, save_context
+
+    project_path = Path(params.path).resolve()
+    context = load_context(project_path)
+
+    if not context:
+        return json.dumps({"error": "No context found. Run forge_init first."})
+
+    # Apply overrides
+    context_data = context.model_dump(mode="json")
+    for key, value in params.overrides.items():
+        if isinstance(value, dict) and key in context_data and isinstance(context_data[key], dict):
+            context_data[key].update(value)
+        else:
+            context_data[key] = value
+
+    from forge_core.models import ProjectContext
+    updated_context = ProjectContext(**context_data)
+    save_context(updated_context, project_path)
+
+    return json.dumps({
+        "status": "updated",
+        "overrides_applied": params.overrides,
+        "context": updated_context.model_dump(mode="json"),
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_detect",
+    annotations={
+        "title": "Detect Project State",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_detect(params: ForgePathInput) -> str:
+    """Detect the current state of a project directory.
+
+    Analyzes the directory to determine: empty, has docs, has code,
+    or has Forge already. Also detects the technology stack from
+    config files and code patterns.
+    """
+    from forge_core.detector import detect_project
+
+    project_path = Path(params.path).resolve()
+    detection = detect_project(project_path)
+
+    return json.dumps({
+        "state": detection.state.value,
+        "has_forge": detection.has_forge,
+        "has_git": detection.has_git,
+        "code_files": len(detection.code_files),
+        "doc_files": len(detection.doc_files),
+        "config_files": [f.name for f in detection.config_files],
+        "detected_stack": detection.detected_stack,
+        "is_greenfield": detection.is_greenfield,
+        "summary": detection.summary(),
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_implementation_phases",
+    annotations={
+        "title": "Get AI-Optimized Implementation Phases",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_implementation_phases(params: ForgePathInput) -> str:
+    """Get the standard AI-optimized implementation phase ordering.
+
+    Returns the 10-phase implementation order designed to minimize
+    AI coding agent hallucinations by ensuring complete context at
+    each step: types → infra → auth → data → services → api →
+    frontend → observability → testing → cicd.
+    """
+    from forge_core.phases.intake import get_implementation_phases
+
+    phases = get_implementation_phases()
+
+    return json.dumps({
+        "total_phases": len(phases),
+        "phases": phases,
+        "philosophy": (
+            "Each phase provides complete context for the next. "
+            "Types and contracts first so the AI agent knows all shapes. "
+            "Infra and auth before any business logic so security is built-in. "
+            "Services before API so endpoints are just thin wrappers. "
+            "Frontend last because it consumes typed API contracts."
+        ),
+    }, indent=2)
+
+
+# ── Editor Bridge Tools ────────────────────────────────────────────────────
+
+
+class ForgeSyncInput(BaseModel):
+    """Input for generating editor instruction files."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    path: str = Field(default=".", description="Path to the project directory.")
+    format: str = Field(
+        default="claude",
+        description="Editor format: claude, cursor, copilot, generic, all",
+    )
+
+
+class ForgeAuditFileInput(BaseModel):
+    """Input for auditing a specific file or code snippet."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    code: str = Field(
+        ...,
+        description="The code content to audit against Forge standards.",
+        min_length=5,
+    )
+    file_path: str = Field(
+        default="unknown",
+        description="The file path for context (e.g., src/api/claims.py).",
+    )
+    path: str = Field(default=".", description="Path to the project directory.")
+
+
+class ForgeAuditProjectInput(BaseModel):
+    """Input for auditing the full project."""
+    model_config = ConfigDict(str_strip_whitespace=True, extra="forbid")
+
+    path: str = Field(default=".", description="Path to the project directory.")
+    target_files: Optional[list[str]] = Field(
+        default=None,
+        description="Specific files to audit. None means full project.",
+    )
+
+
+@mcp.tool(
+    name="forge_sync",
+    annotations={
+        "title": "Generate Editor Instruction Files",
+        "readOnlyHint": False,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_sync(params: ForgeSyncInput) -> str:
+    """Generate CLAUDE.md, .cursorrules, or equivalent from Forge governance.
+
+    This is the core bridge between Forge and the AI editor. It translates
+    ALL governance knowledge — standards, patterns, anti-patterns, project
+    context, journal learnings, security rules, observability requirements,
+    MCP recommendations — into a single file the editor reads and follows.
+
+    Run this after:
+    - forge init (first time)
+    - Adding new standards
+    - Changing project context
+    - Adding journal entries
+    - Upgrading Forge
+    """
+    from forge_core.editor_bridge import write_editor_file
+    from forge_core.phases.context import load_context
+
+    project_path = Path(params.path).resolve()
+    context = load_context(project_path)
+
+    if not context:
+        return json.dumps({"error": "No Forge project found. Run forge_init first."})
+
+    if params.format == "all":
+        formats = ["claude", "cursor", "copilot", "generic"]
+    else:
+        formats = [params.format]
+
+    files_created = []
+    for fmt in formats:
+        path = write_editor_file(project_path, context, fmt)
+        files_created.append(str(path))
+
+    return json.dumps({
+        "status": "synced",
+        "files_created": files_created,
+        "instruction": (
+            "The editor instruction file has been generated. "
+            "The AI editor will read it automatically on next interaction. "
+            "Re-run forge_sync after changing standards or context."
+        ),
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_audit_code",
+    annotations={
+        "title": "Audit Code Against Standards",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_audit_code(params: ForgeAuditFileInput) -> str:
+    """Audit a code snippet or file against all Forge standards.
+
+    Returns the audit prompt that can be processed by the editor's LLM
+    to produce findings. The prompt includes all applicable standards,
+    patterns, security rules, and project context.
+
+    Use this when:
+    - You just generated new code and want to validate it
+    - You're reviewing existing code for compliance
+    - You want to check if code meets regulatory requirements
+    """
+    from forge_core.auditor import build_file_audit_prompt
+    from forge_core.phases.context import load_context
+    from forge_core.registry import load_standards
+
+    project_path = Path(params.path).resolve()
+    context = load_context(project_path)
+
+    if not context:
+        return json.dumps({"error": "No Forge project found. Run forge_init first."})
+
+    standards = load_standards()
+    prompt = build_file_audit_prompt(params.code, params.file_path, context, standards)
+
+    return json.dumps({
+        "status": "audit_ready",
+        "file": params.file_path,
+        "standards_checked": len(standards),
+        "regulatory": [r.value for r in context.regulatory],
+        "audit_prompt": prompt,
+        "instruction": (
+            "Process the audit_prompt with your LLM to generate findings. "
+            "The response will be a JSON array of findings with severity, "
+            "description, and fix for each issue."
+        ),
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_audit_project",
+    annotations={
+        "title": "Audit Entire Project",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_audit_project(params: ForgeAuditProjectInput) -> str:
+    """Generate a full project audit prompt against all Forge standards.
+
+    Produces a comprehensive audit prompt that checks the entire project
+    (or specific files) against all standards, patterns, security rules,
+    and regulatory requirements.
+    """
+    from forge_core.auditor import build_audit_prompt
+    from forge_core.phases.context import load_context
+    from forge_core.registry import load_standards
+
+    project_path = Path(params.path).resolve()
+    context = load_context(project_path)
+
+    if not context:
+        return json.dumps({"error": "No Forge project found. Run forge_init first."})
+
+    standards = load_standards()
+    prompt = build_audit_prompt(project_path, context, standards, params.target_files)
+
+    # Save prompt
+    audit_dir = project_path / ".forge" / "audit"
+    audit_dir.mkdir(parents=True, exist_ok=True)
+    prompt_path = audit_dir / "full_audit_prompt.md"
+    prompt_path.write_text(prompt)
+
+    return json.dumps({
+        "status": "audit_ready",
+        "standards_checked": len(standards),
+        "regulatory": [r.value for r in context.regulatory],
+        "target_files": params.target_files or "all",
+        "prompt_saved_to": str(prompt_path),
+        "audit_prompt": prompt,
+    }, indent=2)
+
+
+@mcp.tool(
+    name="forge_get_rules_for",
+    annotations={
+        "title": "Get Rules for a Specific Task",
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+)
+async def forge_get_rules_for(params: ForgeIntakeInput) -> str:
+    """Get all applicable Forge rules for a specific development task.
+
+    Given a description of what you're about to build (e.g., "new API endpoint
+    for claim submission", "React component for dashboard", "database migration
+    for user table"), returns ALL rules, patterns, and guidelines that apply.
+
+    This is the recommender function — it tells the editor everything it needs
+    to know BEFORE writing code, so the code comes out right the first time.
+
+    Use this at the START of any task, before writing code.
+    """
+    from forge_core.phases.context import load_context
+    from forge_core.registry import load_mcps, load_standards
+
+    project_path = Path(params.path).resolve()
+    context = load_context(project_path)
+
+    if not context:
+        return json.dumps({"error": "No Forge project found. Run forge_init first."})
+
+    standards = load_standards()
+    mcps = load_mcps()
+    task_lower = params.content.lower()
+
+    # Determine which categories are relevant to this task
+    relevant_categories = set()
+    
+    # API-related task
+    if any(w in task_lower for w in ["api", "endpoint", "route", "controller", "rest", "graphql"]):
+        relevant_categories.update(["api-design", "security", "observability", "code-quality"])
+    
+    # Frontend task
+    if any(w in task_lower for w in ["react", "component", "frontend", "ui", "page", "form"]):
+        relevant_categories.update(["code-quality"])
+    
+    # Database task
+    if any(w in task_lower for w in ["database", "migration", "model", "schema", "query", "sql"]):
+        relevant_categories.update(["security", "code-quality"])
+    
+    # Auth task
+    if any(w in task_lower for w in ["auth", "login", "permission", "rbac", "role"]):
+        relevant_categories.update(["security"])
+    
+    # AI task
+    if any(w in task_lower for w in ["ai", "llm", "model", "prompt", "embedding", "inference"]):
+        relevant_categories.update(["security", "observability"])
+    
+    # Default: include everything for unclassified tasks
+    if not relevant_categories:
+        relevant_categories = {"api-design", "security", "observability", "code-quality", "architecture"}
+
+    # Filter standards by relevance
+    applicable_standards = []
+    for std in standards:
+        area = std.get("area", std.get("category", "general"))
+        if area in relevant_categories or "general" in relevant_categories:
+            applicable_standards.append({
+                "name": std.get("name", "unnamed"),
+                "area": area,
+                "enforcement": std.get("enforcement", "required"),
+                "rules": std.get("rules", []),
+                "examples": std.get("examples", {}),
+            })
+    
+    # Always include these for any task
+    always_include = {
+        "type_checking": context.standards.type_checking,
+        "linting": context.standards.linting,
+        "test_coverage_min": context.standards.test_coverage_min,
+    }
+
+    # Load journal for project-specific context
+    journal_path = project_path / ".forge" / "journal.md"
+    journal_content = ""
+    if journal_path.exists():
+        content = journal_path.read_text()
+        if "## Entries" in content:
+            journal_content = content.split("## Entries", 1)[1].strip()
+
+    result = {
+        "task": params.content,
+        "project": context.name,
+        "stack": {
+            "backend": context.backend.value,
+            "frontend": context.frontend.value,
+            "auth": context.auth.value,
+            "database": context.database.value,
+        },
+        "applicable_standards": applicable_standards,
+        "code_quality": always_include,
+        "regulatory": [r.value for r in context.regulatory],
+        "api_config": {
+            "versioning": context.api.versioning,
+            "spec": context.api.spec,
+            "mcp_ready": context.api.mcp_ready,
+        } if "api-design" in relevant_categories else None,
+        "observability_config": {
+            "apm": context.observability.apm,
+            "metrics": context.observability.metrics,
+            "logs": context.observability.logs,
+        } if "observability" in relevant_categories else None,
+        "ai_config": {
+            "enabled": context.ai.enabled,
+            "providers": context.ai.providers,
+            "safety_checks": context.ai.safety_checks,
+        } if context.ai.enabled else None,
+    }
+
+    if journal_content:
+        result["project_specific_context"] = journal_content
+
+    return json.dumps(result, indent=2)
+
+
+# ── Server Entry Point ────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    mcp.run()