codevira 1.6.0__py3-none-any.whl

mcp_server/server.py

@@ -0,0 +1,1049 @@
+"""
+Agent MCP Server
+
+Exposes the project context graph, roadmap, code index, and changeset tracker
+as MCP tools — usable by any MCP-compatible AI coding tool.
+
+Tools:
+  get_node(file_path)                    → graph node: role, connections, rules
+  get_impact(file_path)                  → blast radius before touching a file
+  get_roadmap()                          → current phase, next action, open changesets
+  search_codebase(query, limit, layer)   → semantic search via local ChromaDB
+  list_open_changesets()                 → check for unfinished multi-file work
+  start_changeset(id, desc, files)       → begin tracking a multi-file fix
+  update_changeset_progress(id, file)    → mark a file done within a changeset
+  complete_changeset(id, decisions)      → mark changeset done, record decisions
+  update_node(file_path, changes)        → update graph node after session
+  update_next_action(next_action)        → update roadmap next action
+  refresh_graph(file_paths?)             → auto-generate graph nodes for new files
+  get_signature(file_path)               → skeleton: public symbols, signatures, line ranges
+  get_code(file_path, symbol?)           → full source of one function or class from disk
+
+Usage (Claude Code .claude/settings.json):
+  {
+    "mcpServers": {
+      "codevira": {
+        "command": "codevira",
+        "args": [],
+        "cwd": "/path/to/your-project"
+      }
+    }
+  }
+
+Usage (Cursor / Windsurf): configure via their MCP settings UI with same command.
+"""
+from __future__ import annotations
+
+import sys
+
+try:
+    import mcp.server.stdio
+    from mcp.server import Server
+    from mcp.types import Tool, TextContent
+except ImportError:
+    print("ERROR: mcp package not installed.")
+    print("Run: pip install 'mcp>=1.0.0'")
+    sys.exit(1)
+
+import json
+from mcp_server.tools.graph import (
+    get_node, get_impact, list_nodes, add_node, update_node, refresh_graph,
+    export_graph, get_graph_diff,
+    query_graph as query_graph_tool,
+    analyze_changes as analyze_changes_tool,
+    find_hotspots as find_hotspots_tool,
+)
+from mcp_server.tools.roadmap import (
+    get_roadmap, get_full_roadmap, get_phase,
+    add_phase, update_phase_status, defer_phase,
+    complete_phase, update_next_action,
+    add_open_changeset, remove_open_changeset,
+)
+from mcp_server.tools.search import search_codebase, refresh_index, search_decisions, get_history, write_session_log
+from mcp_server.tools.changesets import (
+    start_changeset,
+    update_changeset_progress,
+    complete_changeset,
+    get_changeset,
+    list_open_changesets,
+)
+from mcp_server.tools.playbook import get_playbook
+from mcp_server.tools.code_reader import get_signature, get_code
+from mcp_server.tools.learning import (
+    get_decision_confidence as learning_get_decision_confidence,
+    get_preferences as learning_get_preferences,
+    get_learned_rules as learning_get_learned_rules,
+    get_project_maturity as learning_get_project_maturity,
+    get_session_context as learning_get_session_context,
+)
+
+server = Server("codevira")
+
+
+# ---- MCP Prompts (workflow templates) ----
+@server.list_prompts()
+async def handle_list_prompts():
+    from mcp_server.prompts import list_prompts as _list_prompts
+    from mcp.types import Prompt, PromptArgument
+    prompts = _list_prompts()
+    return [
+        Prompt(
+            name=p["name"],
+            description=p.get("description"),
+            arguments=[
+                PromptArgument(name=a["name"], description=a.get("description"), required=a.get("required", False))
+                for a in p.get("arguments", [])
+            ],
+        )
+        for p in prompts
+    ]
+
+
+@server.get_prompt()
+async def handle_get_prompt(name: str, arguments: dict | None = None):
+    from mcp_server.prompts import get_prompt as _get_prompt
+    from mcp.types import GetPromptResult, PromptMessage, TextContent as PromptTextContent
+    result = _get_prompt(name, arguments)
+    if not result:
+        raise ValueError(f"Unknown prompt: {name}")
+    return GetPromptResult(
+        description=result["description"],
+        messages=[
+            PromptMessage(role=m["role"], content=PromptTextContent(type="text", text=m["content"]["text"]))
+            for m in result["messages"]
+        ],
+    )
+
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    return [
+        Tool(
+            name="get_node",
+            description=(
+                "Get the context graph node for a file. Returns role, connections, rules, "
+                "stability, tests, and do_not_revert flags. "
+                "Call this INSTEAD of reading the source file to understand what it does."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Relative file path (e.g. 'src/services/generator.py')",
+                    }
+                },
+                "required": ["file_path"],
+            },
+        ),
+        Tool(
+            name="get_impact",
+            description=(
+                "Get the full blast radius for a file before touching it. "
+                "BFS traversal of graph edges to find all downstream affected files. "
+                "ALWAYS call this before modifying any file."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "File you are about to modify",
+                    }
+                },
+                "required": ["file_path"],
+            },
+        ),
+        Tool(
+            name="get_roadmap",
+            description=(
+                "Get current project state: phase number, name, status, next action, "
+                "open changesets, and upcoming phases. Call at the START of every session."
+            ),
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="search_codebase",
+            description=(
+                "Semantic search over the codebase. Returns relevant functions, "
+                "classes, or module docs. Use to find implementation patterns before writing code."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Natural language or code query",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Number of results (default 5, max 10)",
+                        "default": 5,
+                    },
+                    "layer": {
+                        "type": "string",
+                        "description": "Filter by architectural layer",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        Tool(
+            name="get_full_roadmap",
+            description=(
+                "Get the complete roadmap: all completed phases with key decisions, "
+                "current phase, all upcoming phases, and deferred items. "
+                "Use for planning sessions. More expensive than get_roadmap() — "
+                "only call when you need full project history."
+            ),
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="get_phase",
+            description="Get full details of any phase by number — completed, current, or upcoming.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "phase_number": {
+                        "type": ["integer", "string"],
+                        "description": "Phase number (e.g. 19, '8R', '12A')",
+                    }
+                },
+                "required": ["phase_number"],
+            },
+        ),
+        Tool(
+            name="add_phase",
+            description=(
+                "Add a new upcoming phase to the roadmap. "
+                "Call when you identify new work during a session — gaps, refactors, follow-ups. "
+                "High-priority phases are inserted at the front of the queue."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "phase": {"type": ["integer", "string"], "description": "Phase number or label"},
+                    "name": {"type": "string", "description": "Short phase name"},
+                    "description": {"type": "string", "description": "What this phase does and why"},
+                    "priority": {"type": "string", "description": "high | medium | low", "default": "medium"},
+                    "depends_on": {"type": "array", "items": {"type": ["integer", "string"]}},
+                    "files": {"type": "array", "items": {"type": "string"}, "description": "Key files that will be touched"},
+                    "effort": {"type": "string", "description": "Rough estimate e.g. '~2 hours'"},
+                },
+                "required": ["phase", "name", "description"],
+            },
+        ),
+        Tool(
+            name="update_phase_status",
+            description=(
+                "Update the current phase status: pending | in_progress | blocked. "
+                "Call when starting work on a phase (in_progress) or when blocked."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "status": {"type": "string", "description": "pending | in_progress | blocked"},
+                    "blocker": {"type": "string", "description": "Required when status=blocked"},
+                    "started": {"type": "string", "description": "ISO date override (defaults to today)"},
+                },
+                "required": ["status"],
+            },
+        ),
+        Tool(
+            name="defer_phase",
+            description=(
+                "Move an upcoming phase to the deferred list. "
+                "Use when priorities shift or a phase depends on unavailable work."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "phase_number": {"type": ["integer", "string"]},
+                    "reason": {"type": "string", "description": "Why this is being deferred"},
+                },
+                "required": ["phase_number", "reason"],
+            },
+        ),
+        Tool(
+            name="complete_phase",
+            description=(
+                "Mark the current phase as complete and advance to the next upcoming phase. "
+                "Records key_decisions permanently. Requires phase_number to match current phase (safety check)."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "phase_number": {"type": ["integer", "string"], "description": "Must match current phase"},
+                    "key_decisions": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Decisions made — preserved for all future agents",
+                    },
+                },
+                "required": ["phase_number", "key_decisions"],
+            },
+        ),
+        Tool(
+            name="list_open_changesets",
+            description=(
+                "List all in-progress multi-file changesets. "
+                "Call at session start to check for unfinished work from previous sessions."
+            ),
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="start_changeset",
+            description=(
+                "Begin tracking a multi-file fix. Call BEFORE touching any files. "
+                "Creates a changeset record for cross-session continuity."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "changeset_id": {
+                        "type": "string",
+                        "description": "Short slug (e.g. 'auth-refactor')",
+                    },
+                    "description": {"type": "string"},
+                    "files": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "All files that will be modified",
+                    },
+                    "trigger": {
+                        "type": "string",
+                        "enum": ["small_fix", "medium_change", "large_change"],
+                        "default": "medium_change",
+                    },
+                },
+                "required": ["changeset_id", "description", "files"],
+            },
+        ),
+        Tool(
+            name="update_changeset_progress",
+            description="Mark a file as done within an active changeset.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "changeset_id": {"type": "string"},
+                    "file_done": {"type": "string", "description": "File path that was completed"},
+                    "blocker": {"type": "string", "description": "Optional blocker note if session ending early"},
+                },
+                "required": ["changeset_id", "file_done"],
+            },
+        ),
+        Tool(
+            name="complete_changeset",
+            description=(
+                "Mark a changeset as complete and record key decisions. "
+                "Call at session end after all files in the changeset are done."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "changeset_id": {"type": "string"},
+                    "decisions": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Key decisions made (preserved for future agents)",
+                    },
+                },
+                "required": ["changeset_id", "decisions"],
+            },
+        ),
+        Tool(
+            name="update_node",
+            description=(
+                "Update a graph node after modifying a file. "
+                "Call at session end for each file you changed."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string"},
+                    "changes": {
+                        "type": "object",
+                        "description": "Fields to update: last_changed_by (str), new_rules (list), do_not_revert (bool)",
+                    },
+                },
+                "required": ["file_path", "changes"],
+            },
+        ),
+        Tool(
+            name="list_nodes",
+            description=(
+                "List all nodes in the context graph with brief summaries. "
+                "Use at session start to discover what's in the graph and spot stale files. "
+                "Filter by layer, do_not_revert, or stability."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "layer": {
+                        "type": "string",
+                        "description": "Filter by architectural layer",
+                    },
+                    "do_not_revert": {
+                        "type": "boolean",
+                        "description": "If true, return only protected nodes",
+                    },
+                    "stability": {
+                        "type": "string",
+                        "description": "Filter by stability: low | medium | high",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="add_node",
+            description=(
+                "Add a new node to the context graph for a newly created file. "
+                "Call this after creating a new file. Graph file is auto-inferred from path."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Relative file path"},
+                    "role": {"type": "string", "description": "One-line description of what the file does"},
+                    "layer": {"type": "string", "description": "Architectural layer"},
+                    "stability": {"type": "string", "description": "low | medium | high", "default": "medium"},
+                    "node_type": {"type": "string", "description": "file | service | schema | event", "default": "file"},
+                    "key_functions": {"type": "array", "items": {"type": "string"}},
+                    "connects_to": {
+                        "type": "array",
+                        "items": {"type": "object"},
+                        "description": "Edge list: [{target, edge, via}]",
+                    },
+                    "rules": {"type": "array", "items": {"type": "string"}},
+                    "do_not_revert": {"type": "boolean", "default": False},
+                    "tests": {"type": "array", "items": {"type": "string"}},
+                },
+                "required": ["file_path", "role", "layer"],
+            },
+        ),
+        Tool(
+            name="search_decisions",
+            description=(
+                "Search past decisions across all completed changesets, roadmap phases, and session logs. "
+                "Answers 'has anyone decided this before?' — gives agents institutional memory."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Keywords to search (e.g. 'threshold', 'uuid', 'retry')"},
+                    "limit": {"type": "integer", "description": "Max results (default 10)", "default": 10},
+                    "session_id": {"type": "string", "description": "Optional — filter results to a specific session only"},
+                },
+                "required": ["query"],
+            },
+        ),
+        Tool(
+            name="get_history",
+            description=(
+                "Get the last N git commits that touched a file. "
+                "Links graph node last_changed_by to actual commits."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Relative file path"},
+                },
+                "required": ["file_path"],
+            },
+        ),
+        Tool(
+            name="write_session_log",
+            description=(
+                "Write a structured session log to .agents/logs/YYYY-MM-DD/. "
+                "Called by the Documenter at the end of every session. "
+                "Feeds search_decisions() with institutional memory."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "session_id": {"type": "string", "description": "Short ID (8-char slug)"},
+                    "task": {"type": "string", "description": "Original developer prompt"},
+                    "phase": {"type": "string", "description": "phase"},
+                    "files_changed": {"type": "array", "items": {"type": "string"}},
+                    "decisions": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "file_path": {"type": "string"},
+                                "decision": {"type": "string"},
+                                "context": {"type": "string"}
+                            }
+                        }
+                    },
+                    "next_steps": {"type": "array", "items": {"type": "string"}}
+                },
+                "required": ["session_id", "task", "phase", "files_changed", "decisions", "next_steps"],
+            },
+        ),
+        Tool(
+            name="refresh_index",
+            description=(
+                "Trigger an incremental reindex of changed files. "
+                "Call when get_node() returns index_status.stale=true, or before searching "
+                "files you know have changed. Pass file_paths to reindex specific files only."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_paths": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Specific files to reindex. Omit to reindex all changed files.",
+                    }
+                },
+            },
+        ),
+        Tool(
+            name="get_playbook",
+            description=(
+                "Get curated architectural rules for a specific task type. "
+                "Returns only the 2-3 relevant rule files — not all of them. "
+                "Use for: add_route | add_service | add_schema | "
+                "debug_pipeline | commit | write_test"
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "task_type": {
+                        "type": "string",
+                        "description": "Task type (e.g. 'add_route', 'debug_pipeline', 'commit')",
+                    }
+                },
+                "required": ["task_type"],
+            },
+        ),
+        Tool(
+            name="update_next_action",
+            description="Update the roadmap's next_action field. Call at session end.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "next_action": {
+                        "type": "string",
+                        "description": "Exact description of what the next agent should do",
+                    }
+                },
+                "required": ["next_action"],
+            },
+        ),
+        Tool(
+            name="refresh_graph",
+            description=(
+                "Auto-generate context graph nodes for new or unregistered files. "
+                "Call after creating a new file to get a graph stub immediately — "
+                "no CLI needed. Safe merge: existing enriched nodes are never overwritten. "
+                "Pass file_paths to target specific files, or omit to scan all new files."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_paths": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": (
+                            "Relative file paths to generate nodes for. "
+                            "Omit to auto-detect all Python files not yet in the graph."
+                        ),
+                    }
+                },
+            },
+        ),
+        Tool(
+            name="get_signature",
+            description=(
+                "Get the skeleton of a Python file — all public function and class names, "
+                "their signatures, docstrings, and line ranges. "
+                "Call this after get_node() to understand file structure before deciding "
+                "which symbol to read with get_code(). Much cheaper than reading the full file. "
+                "Note: Python files only. For other languages, read the file directly."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Relative file path (e.g. 'src/services/generator.py')",
+                    }
+                },
+                "required": ["file_path"],
+            },
+        ),
+        Tool(
+            name="get_code",
+            description=(
+                "Get the full source of a single function or class by name. "
+                "Always reads from disk — always current, never stale. "
+                "Call get_signature() first to discover available symbol names and line ranges. "
+                "Omit symbol to get module-level constants and assignments only. "
+                "Note: Python files only. For other languages, read the file directly."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Relative file path",
+                    },
+                    "symbol": {
+                        "type": "string",
+                        "description": "Function or class name to retrieve. Omit for module-level constants.",
+                    },
+                },
+                "required": ["file_path"],
+            },
+        ),
+        # ---- v1.4: Graph Visualization & Diff ----
+        Tool(
+            name="export_graph",
+            description=(
+                "Export the dependency graph as a Mermaid or DOT diagram. "
+                "Use for documentation, PR descriptions, or onboarding. "
+                "Pass scope to limit to a directory (e.g. 'src/services/')."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "format": {
+                        "type": "string",
+                        "enum": ["mermaid", "dot"],
+                        "description": "Output format: 'mermaid' or 'dot'",
+                        "default": "mermaid",
+                    },
+                    "scope": {
+                        "type": "string",
+                        "description": "Filter to files under this directory prefix",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="get_graph_diff",
+            description=(
+                "Show which graph nodes changed between two git refs and their blast radius. "
+                "Use before opening a PR to understand the impact of your changes. "
+                "Defaults to comparing main...HEAD."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "base_ref": {
+                        "type": "string",
+                        "description": "Base git ref (default: 'main')",
+                        "default": "main",
+                    },
+                    "head_ref": {
+                        "type": "string",
+                        "description": "Head git ref (default: 'HEAD')",
+                        "default": "HEAD",
+                    },
+                },
+            },
+        ),
+        # ---- v1.4: Learning & Adaptive Memory ----
+        Tool(
+            name="get_decision_confidence",
+            description=(
+                "Get confidence scores for a file or pattern based on outcome history. "
+                "Returns how often past decisions were kept, modified, or reverted. "
+                "Call this before making decisions in an area to gauge reliability."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Specific file to check confidence for",
+                    },
+                    "pattern": {
+                        "type": "string",
+                        "description": "Directory or file pattern to check (e.g. 'src/api/')",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="get_preferences",
+            description=(
+                "Get learned developer preferences from past correction patterns. "
+                "Returns coding style signals: naming conventions, structural preferences, patterns. "
+                "Call this before writing code to match the developer's style."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "category": {
+                        "type": "string",
+                        "description": "Filter by category: 'naming' | 'structure' | 'patterns' | 'formatting'",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="get_learned_rules",
+            description=(
+                "Get auto-generated rules from observed patterns across sessions. "
+                "These rules are learned from what works — test pairing patterns, import rules, "
+                "co-change patterns. Higher confidence = more reliable. "
+                "Use alongside get_playbook() for comprehensive guidance."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "File path to get rules for (matches by pattern)",
+                    },
+                    "category": {
+                        "type": "string",
+                        "description": "Filter: 'testing' | 'imports' | 'structure' | 'patterns' | 'naming'",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="get_project_maturity",
+            description=(
+                "Get overall project intelligence and maturity metrics. "
+                "Shows session count, file coverage, confidence score, learned rules, "
+                "and preference signals. The higher the score, the less ambiguous agent decisions are."
+            ),
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="get_session_context",
+            description=(
+                "Single 'catch me up' call for cross-tool continuity. "
+                "Returns current roadmap phase, open changesets, recent decisions with confidence, "
+                "learned preferences, and active rules — everything a new session needs. "
+                "Call this at the START of every session instead of multiple separate calls. "
+                "Works seamlessly across AI tools: Cursor, Claude Code, Windsurf, Antigravity."
+            ),
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        # ---- v1.5: Deep Graph Intelligence Tools ----
+        Tool(
+            name="query_graph",
+            description=(
+                "Query the function-level call graph. Find callers, callees, tests, or dependents "
+                "for a specific symbol. Use query_type='symbols' to list all functions in a file."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string", "description": "Relative file path"},
+                    "symbol": {"type": "string", "description": "Function or class name to query"},
+                    "query_type": {
+                        "type": "string",
+                        "description": "callers | callees | tests | dependents | symbols",
+                        "default": "callees",
+                    },
+                },
+                "required": ["file_path"],
+            },
+        ),
+        Tool(
+            name="analyze_changes",
+            description=(
+                "Function-level risk-scored change analysis. Maps git diff to affected functions, "
+                "counts callers, flags test coverage gaps, assigns risk scores (high/medium/low). "
+                "Use before code review or pre-commit."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "base_ref": {"type": "string", "description": "Base git ref (default: main)", "default": "main"},
+                    "head_ref": {"type": "string", "description": "Head git ref (default: HEAD)", "default": "HEAD"},
+                },
+            },
+        ),
+        Tool(
+            name="find_hotspots",
+            description=(
+                "Find complexity and risk hotspots: large functions (exceeding line threshold), "
+                "high fan-in symbols (many callers = risky to change), and high fan-out files "
+                "(many dependencies = fragile)."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "threshold": {"type": "integer", "description": "Min lines for large function (default: 50)", "default": 50},
+                },
+            },
+        ),
+    ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    # v1.6: Auto-init check — triggers background init on first call if needed.
+    # This is a no-op (<1ms) on every subsequent call after initialization.
+    try:
+        from mcp_server.auto_init import ensure_project_initialized
+        ensure_project_initialized()
+    except Exception:
+        pass  # auto-init must never block tool dispatch
+
+    try:
+        if name == "get_node":
+            result = get_node(arguments["file_path"])
+        elif name == "get_impact":
+            result = get_impact(arguments["file_path"])
+        elif name == "get_roadmap":
+            result = get_roadmap()
+        elif name == "get_full_roadmap":
+            result = get_full_roadmap()
+        elif name == "get_phase":
+            result = get_phase(arguments["phase_number"])
+        elif name == "add_phase":
+            result = add_phase(
+                phase=arguments["phase"],
+                name=arguments["name"],
+                description=arguments["description"],
+                priority=arguments.get("priority", "medium"),
+                depends_on=arguments.get("depends_on"),
+                files=arguments.get("files"),
+                effort=arguments.get("effort"),
+            )
+        elif name == "update_phase_status":
+            result = update_phase_status(
+                status=arguments["status"],
+                blocker=arguments.get("blocker"),
+                started=arguments.get("started"),
+            )
+        elif name == "defer_phase":
+            result = defer_phase(
+                phase_number=arguments["phase_number"],
+                reason=arguments["reason"],
+            )
+        elif name == "complete_phase":
+            result = complete_phase(
+                phase_number=arguments["phase_number"],
+                key_decisions=arguments["key_decisions"],
+            )
+        elif name == "search_codebase":
+            result = search_codebase(
+                arguments["query"],
+                top_k=arguments.get("limit", 5),
+            )
+        elif name == "list_open_changesets":
+            result = list_open_changesets()
+        elif name == "start_changeset":
+            result = start_changeset(
+                arguments["changeset_id"],
+                arguments["description"],
+                arguments["files"],
+                trigger=arguments.get("trigger", "medium_change"),
+            )
+        elif name == "update_changeset_progress":
+            result = update_changeset_progress(
+                arguments["changeset_id"],
+                arguments["file_done"],
+                blocker=arguments.get("blocker"),
+            )
+        elif name == "complete_changeset":
+            result = complete_changeset(
+                arguments["changeset_id"],
+                arguments["decisions"],
+            )
+        elif name == "update_node":
+            result = update_node(
+                arguments["file_path"],
+                arguments["changes"],
+            )
+        elif name == "list_nodes":
+            result = list_nodes(
+                layer=arguments.get("layer"),
+                do_not_revert=arguments.get("do_not_revert"),
+                stability=arguments.get("stability"),
+            )
+        elif name == "add_node":
+            result = add_node(
+                file_path=arguments["file_path"],
+                role=arguments["role"],
+                layer=arguments["layer"],
+                stability=arguments.get("stability", "medium"),
+                node_type=arguments.get("node_type", "file"),
+                key_functions=arguments.get("key_functions"),
+                connects_to=arguments.get("connects_to"),
+                rules=arguments.get("rules"),
+                do_not_revert=arguments.get("do_not_revert", False),
+                tests=arguments.get("tests"),
+            )
+        elif name == "search_decisions":
+            result = search_decisions(
+                arguments["query"],
+                limit=arguments.get("limit", 10),
+                session_id=arguments.get("session_id"),
+            )
+        elif name == "get_history":
+            result = get_history(arguments["file_path"])
+        elif name == "write_session_log":
+            result = write_session_log(
+                session_id=arguments["session_id"],
+                task=arguments["task"],
+                phase=arguments["phase"],
+                files_changed=arguments["files_changed"],
+                decisions=arguments["decisions"],
+                next_steps=arguments["next_steps"],
+            )
+        elif name == "refresh_index":
+            result = refresh_index(file_paths=arguments.get("file_paths") or [])
+        elif name == "get_playbook":
+            result = get_playbook(arguments["task_type"])
+        elif name == "update_next_action":
+            result = update_next_action(arguments["next_action"])
+        elif name == "refresh_graph":
+            result = refresh_graph(file_paths=arguments.get("file_paths"))
+        elif name == "get_signature":
+            result = get_signature(arguments["file_path"])
+        elif name == "get_code":
+            result = get_code(arguments["file_path"], symbol=arguments.get("symbol"))
+        # ---- v1.4: Graph Visualization & Diff ----
+        elif name == "export_graph":
+            result = export_graph(
+                format=arguments.get("format", "mermaid"),
+                scope=arguments.get("scope"),
+            )
+        elif name == "get_graph_diff":
+            result = get_graph_diff(
+                base_ref=arguments.get("base_ref", "main"),
+                head_ref=arguments.get("head_ref", "HEAD"),
+            )
+        # ---- v1.4: Learning & Adaptive Memory ----
+        elif name == "get_decision_confidence":
+            result = learning_get_decision_confidence(
+                file_path=arguments.get("file_path"),
+                pattern=arguments.get("pattern"),
+            )
+        elif name == "get_preferences":
+            result = learning_get_preferences(category=arguments.get("category"))
+        elif name == "get_learned_rules":
+            result = learning_get_learned_rules(
+                file_path=arguments.get("file_path"),
+                category=arguments.get("category"),
+            )
+        elif name == "get_project_maturity":
+            result = learning_get_project_maturity()
+        elif name == "get_session_context":
+            result = learning_get_session_context()
+        # ---- v1.5: Deep Graph Intelligence ----
+        elif name == "query_graph":
+            result = query_graph_tool(
+                file_path=arguments["file_path"],
+                symbol=arguments.get("symbol"),
+                query_type=arguments.get("query_type", "callees"),
+            )
+        elif name == "analyze_changes":
+            result = analyze_changes_tool(
+                base_ref=arguments.get("base_ref", "main"),
+                head_ref=arguments.get("head_ref", "HEAD"),
+            )
+        elif name == "find_hotspots":
+            result = find_hotspots_tool(
+                threshold=arguments.get("threshold", 50),
+            )
+        else:
+            result = {"error": f"Unknown tool: {name}"}
+
+    except Exception as e:
+        result = {"error": str(e), "tool": name}
+        # Log crashes with full traceback (sanitized, no secrets)
+        try:
+            from mcp_server.crash_logger import log_crash
+            from mcp_server.paths import get_project_root
+            log_crash(e, context="tool dispatch", tool_name=name,
+                      project_path=str(get_project_root()))
+        except Exception:
+            pass  # crash logger must never break the server
+
+    return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+
+def main():
+    import asyncio
+    import logging
+
+    logger = logging.getLogger("codevira.server")
+
+    # Install global crash handler — catches unhandled exceptions
+    try:
+        from mcp_server.crash_logger import install_global_handler, log_crash
+        install_global_handler()
+    except Exception as e:
+        logger.warning("Could not install crash handler: %s", e)
+
+    # v1.6: Auto-migrate legacy .codevira/ → ~/.codevira/projects/<key>/
+    try:
+        from mcp_server.migrate import detect_migration_needed, migrate_to_centralized
+        from mcp_server.paths import get_project_root
+        _proj_root = get_project_root()
+        if detect_migration_needed(_proj_root):
+            logger.info("Migrating legacy .codevira/ to centralized storage...")
+            result = migrate_to_centralized(_proj_root)
+            if result.get("migrated"):
+                logger.info("Migration complete: %d files moved to %s",
+                            result.get("files_copied", 0), result.get("new_path", ""))
+    except Exception as e:
+        logger.warning("Could not run storage migration: %s", e)
+
+    # Auto-start background file watcher so the index stays fresh
+    # on every file save — no manual trigger or git commit needed.
+    watcher = None
+    try:
+        from indexer.index_codebase import start_background_watcher
+        watcher = start_background_watcher(quiet=True)
+        logger.info("Live file watcher active — index updates on save")
+    except Exception as e:
+        # Watcher is best-effort; don't block server startup
+        logger.warning("Could not start background watcher: %s", e)
+        try: log_crash(e, context="background watcher startup")
+        except Exception: pass
+
+    # v1.4: Run outcome analysis and rule inference on startup
+    # This processes any sessions that haven't been analyzed yet.
+    try:
+        from indexer.outcome_tracker import analyze_session_outcomes
+        from indexer.rule_learner import run_rule_inference
+        analyze_session_outcomes()
+        run_rule_inference()
+        logger.info("Outcome analysis and rule inference complete")
+    except Exception as e:
+        logger.warning("Could not run startup learning: %s", e)
+        try: log_crash(e, context="startup learning pipeline")
+        except Exception: pass
+
+    # v1.5: Import global intelligence from cross-project memory
+    try:
+        from mcp_server.global_sync import import_global_to_project
+        stats = import_global_to_project()
+        if stats.get("preferences_imported") or stats.get("rules_imported"):
+            logger.info("Global memory: imported %d preferences, %d rules",
+                        stats["preferences_imported"], stats["rules_imported"])
+    except Exception as e:
+        logger.warning("Could not sync global memory: %s", e)
+        try: log_crash(e, context="global memory import")
+        except Exception: pass
+
+    async def _run():
+        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+            await server.run(
+                read_stream,
+                write_stream,
+                server.create_initialization_options(),
+            )
+
+    try:
+        asyncio.run(_run())
+    finally:
+        if watcher is not None:
+            watcher.stop()
+
+
+if __name__ == "__main__":
+    main()