codevira 1.6.0__py3-none-any.whl

mcp_server/tools/changesets.py

@@ -0,0 +1,223 @@
+"""
+MCP tools for managing multi-file change sets.
+Tracks in-progress fixes that span multiple files across sessions.
+"""
+from __future__ import annotations
+
+from datetime import date
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from mcp_server.paths import get_data_dir
+
+
+def _changesets_dir() -> Path:
+    return get_data_dir() / "graph" / "changesets"
+
+
+def _changeset_path(changeset_id: str) -> Path:
+    return _changesets_dir() / f"{changeset_id}.yaml"
+
+
+def start_changeset(
+    changeset_id: str,
+    description: str,
+    files: list[str],
+    trigger: str = "medium_change",
+) -> dict[str, Any]:
+    """
+    Begin tracking a multi-file fix. Call BEFORE touching any files.
+
+    Args:
+        changeset_id: Short slug (e.g. "synonym-pipeline-fix")
+        description: What this changeset does
+        files: All files that will be modified (include ones not yet modified)
+        trigger: small_fix | medium_change | large_change
+
+    Creates .agents/graph/changesets/{id}.yaml
+    """
+    _changesets_dir().mkdir(parents=True, exist_ok=True)
+    path = _changeset_path(changeset_id)
+
+    if path.exists():
+        return {
+            "success": False,
+            "message": f"Changeset '{changeset_id}' already exists. Use a different ID or complete the existing one.",
+        }
+
+    data = {
+        "id": changeset_id,
+        "status": "in_progress",
+        "created": date.today().isoformat(),
+        "trigger": trigger,
+        "description": description,
+        "files_modified": [],
+        "files_pending": files,
+        "blocker": None,
+        "decisions": [],
+    }
+
+    with open(path, "w") as f:
+        yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+    return {"success": True, "changeset_id": changeset_id, "tracking": files}
+
+
+def update_changeset_progress(
+    changeset_id: str,
+    file_done: str,
+    blocker: str | None = None,
+) -> dict[str, Any]:
+    """
+    Move a file from files_pending to files_modified.
+    Call after each file is completed within the changeset.
+    """
+    path = _changeset_path(changeset_id)
+    if not path.exists():
+        return {"success": False, "message": f"Changeset '{changeset_id}' not found."}
+
+    with open(path) as f:
+        data = yaml.safe_load(f)
+
+    pending = data.get("files_pending", [])
+    modified = data.get("files_modified", [])
+
+    if file_done in pending:
+        pending.remove(file_done)
+    if file_done not in modified:
+        modified.append(file_done)
+
+    data["files_pending"] = pending
+    data["files_modified"] = modified
+    if blocker is not None:
+        data["blocker"] = blocker
+
+    with open(path, "w") as f:
+        yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+    return {
+        "success": True,
+        "files_done": len(modified),
+        "files_remaining": len(pending),
+        "blocker": blocker,
+    }
+
+
+def complete_changeset(changeset_id: str, decisions: list[str]) -> dict[str, Any]:
+    """
+    Mark a changeset as complete. Call at session end after all files are done.
+
+    Args:
+        changeset_id: The changeset to complete
+        decisions: Key decisions made (e.g. "synonyms in text only, not metadata")
+                   These are written to the changeset record for future agents.
+    """
+    path = _changeset_path(changeset_id)
+    if not path.exists():
+        return {"success": False, "message": f"Changeset '{changeset_id}' not found."}
+
+    with open(path) as f:
+        data = yaml.safe_load(f)
+
+    if data.get("files_pending"):
+        return {
+            "success": False,
+            "message": f"Cannot complete — {len(data['files_pending'])} files still pending: {data['files_pending']}",
+            "hint": "Either finish the pending files or document the blocker with update_changeset_progress.",
+        }
+
+    data["status"] = "complete"
+    data["completed"] = date.today().isoformat()
+    data["decisions"] = decisions
+    data["blocker"] = None
+
+    with open(path, "w") as f:
+        yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+    return {"success": True, "changeset_id": changeset_id, "decisions_recorded": len(decisions)}
+
+
+def get_changeset(changeset_id: str) -> dict[str, Any]:
+    """Get the current state of a changeset."""
+    path = _changeset_path(changeset_id)
+    if not path.exists():
+        return {"found": False, "message": f"Changeset '{changeset_id}' not found."}
+
+    with open(path) as f:
+        data = yaml.safe_load(f)
+    return {"found": True, "changeset": data}
+
+
+def list_open_changesets() -> dict[str, Any]:
+    """List all in-progress changesets. Call at session start to check for unfinished work."""
+    _changesets_dir().mkdir(parents=True, exist_ok=True)
+    open_cs = []
+    for yaml_file in _changesets_dir().glob("*.yaml"):
+        try:
+            with open(yaml_file) as f:
+                data = yaml.safe_load(f)
+            if data and data.get("status") == "in_progress":
+                open_cs.append({
+                    "id": data["id"],
+                    "description": data.get("description", ""),
+                    "created": data.get("created", ""),
+                    "files_pending": data.get("files_pending", []),
+                    "blocker": data.get("blocker"),
+                })
+        except Exception as e:
+            try:
+                from mcp_server.crash_logger import log_crash
+                log_crash(e, context=f"list_open_changesets: reading {yaml_file.name}")
+            except Exception:
+                pass
+
+    return {
+        "open_changesets": open_cs,
+        "count": len(open_cs),
+        "warning": "Complete or document blockers before starting new work." if open_cs else None,
+    }
+
+
+def update_node_after_change(file_path: str, changes: dict[str, Any]) -> dict[str, Any]:
+    """
+    Update a graph node's metadata after making changes to that file.
+    Called by the documenter agent at session end.
+
+    Args:
+        file_path: The file that was changed
+        changes: Dict with any of: last_changed_by, new_rules (list), new_connections (list)
+    """
+    from mcp_server.tools.graph import update_node
+
+    translated_changes: dict[str, Any] = {}
+    passthrough_fields = {"key_functions", "stability", "do_not_revert"}
+
+    for field in passthrough_fields:
+        if field in changes:
+            translated_changes[field] = changes[field]
+
+    if "new_rules" in changes:
+        translated_changes["rules"] = changes["new_rules"]
+    if "new_connections" in changes:
+        translated_changes["connects_to"] = changes["new_connections"]
+
+    result = update_node(file_path, translated_changes)
+
+    if "error" in result:
+        return {
+            "success": False,
+            "message": result["error"],
+        }
+
+    response = {
+        "success": True,
+        "updated_node": file_path,
+    }
+    if "last_changed_by" in changes:
+        response["note"] = (
+            "Node metadata updated. 'last_changed_by' is not persisted in the SQLite graph schema."
+        )
+
+    return response

mcp_server/tools/code_reader.py

@@ -0,0 +1,335 @@
+"""
+code_reader.py — MCP tools for reading source files
+
+get_signature(file_path)       → skeleton: all public symbols, signatures, docstrings, line ranges
+get_code(file_path, symbol)    → full source of one named function or class from disk
+
+Always reads from disk. No index, no ChromaDB, no staleness risk.
+
+Language support:
+  - Python: stdlib ast module (full support)
+  - TypeScript, Go, Rust: tree-sitter grammars via treesitter_parser
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp_server.paths import get_project_root
+from indexer.treesitter_parser import (
+    parse_file as ts_parse_file,
+    get_symbol_source as ts_get_symbol_source,
+    get_language as ts_get_language,
+    EXTENSION_MAP as TS_EXTENSION_MAP,
+)
+
+
+def _resolve(file_path: str) -> Path:
+    """Resolve relative file path to absolute using the project root."""
+    p = Path(file_path)
+    if p.is_absolute():
+        return p
+    return get_project_root() / p
+
+
+def _is_private(name: str) -> bool:
+    return name.startswith("_")
+
+
+def _node_kind(node: ast.AST) -> str:
+    if isinstance(node, ast.ClassDef):
+        return "class"
+    return "function"
+
+
+def _signature_line(source_lines: list[str], node: ast.AST) -> str:
+    """Return the def/class line (first line of the node), stripped."""
+    return source_lines[node.lineno - 1].strip()
+
+
+def get_signature(file_path: str) -> dict:
+    """
+    Get the skeleton of a source file: all public function and class names,
+    their signatures, docstrings, and line ranges.
+
+    Supports Python, TypeScript, Go, and Rust.
+
+    Args:
+        file_path: Relative path from project root (e.g. 'src/services/generator.py')
+
+    Returns:
+        dict with module_docstring, symbols list, and file metadata
+    """
+    abs_path = _resolve(file_path)
+
+    if not abs_path.exists():
+        return {
+            "found": False,
+            "file_path": file_path,
+            "error": f"File not found: {abs_path}",
+        }
+
+    ext = abs_path.suffix.lower()
+
+    # Non-Python: dispatch to tree-sitter
+    if ext in TS_EXTENSION_MAP:
+        return _get_signature_treesitter(file_path, abs_path)
+
+    # Python: existing ast-based extraction
+    if ext == ".py":
+        return _get_signature_python(file_path, abs_path)
+
+    return {
+        "found": False,
+        "file_path": file_path,
+        "error": f"Unsupported file type: {ext}. Supported: .py, .ts, .tsx, .go, .rs",
+    }
+
+
+def _get_signature_treesitter(file_path: str, abs_path: Path) -> dict:
+    """Get file skeleton using tree-sitter for TS/Go/Rust files."""
+    try:
+        parsed = ts_parse_file(str(abs_path))
+    except (ValueError, FileNotFoundError) as e:
+        return {
+            "found": False,
+            "file_path": file_path,
+            "error": str(e),
+        }
+
+    symbols = []
+    for sym in parsed.symbols:
+        if not sym.is_public:
+            continue
+
+        entry = {
+            "name": sym.name,
+            "kind": sym.kind,
+            "signature_line": sym.signature_line,
+            "start_line": sym.start_line,
+            "end_line": sym.end_line,
+        }
+        if sym.docstring:
+            first_line = sym.docstring.strip().splitlines()[0]
+            entry["docstring"] = first_line
+
+        if sym.methods:
+            entry["public_methods"] = sym.methods
+
+        symbols.append(entry)
+
+    return {
+        "found": True,
+        "file_path": file_path,
+        "language": parsed.language,
+        "module_docstring": parsed.module_docstring,
+        "symbol_count": len(symbols),
+        "symbols": symbols,
+        "hint": "Use get_code(file_path, symbol) to read the full body of any symbol listed above.",
+    }
+
+
+def _get_signature_python(file_path: str, abs_path: Path) -> dict:
+    """Get file skeleton using Python ast module."""
+    source = abs_path.read_text(encoding="utf-8")
+    source_lines = source.splitlines()
+
+    try:
+        tree = ast.parse(source, filename=str(abs_path))
+    except SyntaxError as e:
+        return {
+            "found": False,
+            "file_path": file_path,
+            "error": f"Syntax error: {e}",
+        }
+
+    module_docstring = ast.get_docstring(tree) or None
+
+    symbols = []
+    for node in tree.body:
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            continue
+        if _is_private(node.name):
+            continue
+
+        kind = _node_kind(node)
+        sig_line = _signature_line(source_lines, node)
+        docstring = ast.get_docstring(node) or None
+
+        entry = {
+            "name": node.name,
+            "kind": kind,
+            "signature_line": sig_line,
+            "start_line": node.lineno,
+            "end_line": node.end_lineno,
+        }
+        if docstring:
+            first_line = docstring.strip().splitlines()[0]
+            entry["docstring"] = first_line
+
+        if kind == "class":
+            methods = []
+            for child in ast.walk(node):
+                if child is node:
+                    continue
+                if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    if not _is_private(child.name) and child.name != "__init__":
+                        methods.append(child.name)
+            if methods:
+                entry["public_methods"] = methods
+
+        symbols.append(entry)
+
+    return {
+        "found": True,
+        "file_path": file_path,
+        "module_docstring": module_docstring,
+        "symbol_count": len(symbols),
+        "symbols": symbols,
+        "hint": "Use get_code(file_path, symbol) to read the full body of any symbol listed above.",
+    }
+
+
+def get_code(file_path: str, symbol: str | None = None) -> dict:
+    """
+    Get the full source of a single function or class by name.
+    Always reads from disk — always current.
+
+    Supports Python, TypeScript, Go, and Rust.
+
+    Args:
+        file_path: Relative path from project root
+        symbol: Function or class name. Omit to get module-level constants/assignments only.
+
+    Returns:
+        dict with source, start_line, end_line, kind, docstring
+    """
+    abs_path = _resolve(file_path)
+
+    if not abs_path.exists():
+        return {
+            "found": False,
+            "file_path": file_path,
+            "symbol": symbol,
+            "error": f"File not found: {abs_path}",
+        }
+
+    ext = abs_path.suffix.lower()
+
+    # Non-Python: dispatch to tree-sitter
+    if ext in TS_EXTENSION_MAP:
+        return _get_code_treesitter(file_path, abs_path, symbol)
+
+    # Python: existing ast-based extraction
+    if ext == ".py":
+        return _get_code_python(file_path, abs_path, symbol)
+
+    return {
+        "found": False,
+        "file_path": file_path,
+        "symbol": symbol,
+        "error": f"Unsupported file type: {ext}. Supported: .py, .ts, .tsx, .go, .rs",
+    }
+
+
+def _get_code_treesitter(file_path: str, abs_path: Path, symbol: str | None) -> dict:
+    """Get symbol source using tree-sitter for TS/Go/Rust files."""
+    # symbol=None → return module-level info
+    if symbol is None:
+        try:
+            parsed = ts_parse_file(str(abs_path))
+        except (ValueError, FileNotFoundError) as e:
+            return {
+                "found": False,
+                "file_path": file_path,
+                "symbol": None,
+                "error": str(e),
+            }
+        return {
+            "found": True,
+            "file_path": file_path,
+            "symbol": None,
+            "kind": "module_info",
+            "language": parsed.language,
+            "module_docstring": parsed.module_docstring,
+            "imports": [imp.module for imp in parsed.imports],
+        }
+
+    # Named symbol lookup
+    result = ts_get_symbol_source(str(abs_path), symbol)
+    result["file_path"] = file_path
+    return result
+
+
+def _get_code_python(file_path: str, abs_path: Path, symbol: str | None) -> dict:
+    """Get symbol source using Python ast module."""
+    source = abs_path.read_text(encoding="utf-8")
+    source_lines = source.splitlines()
+
+    try:
+        tree = ast.parse(source, filename=str(abs_path))
+    except SyntaxError as e:
+        return {
+            "found": False,
+            "file_path": file_path,
+            "symbol": symbol,
+            "error": f"Syntax error: {e}",
+        }
+
+    # symbol=None → return module-level non-function, non-class content
+    if symbol is None:
+        module_docstring = ast.get_docstring(tree) or None
+        assignments = []
+        for node in tree.body:
+            if isinstance(node, (ast.Assign, ast.AnnAssign, ast.AugAssign)):
+                lines = source_lines[node.lineno - 1 : node.end_lineno]
+                assignments.append({
+                    "start_line": node.lineno,
+                    "end_line": node.end_lineno,
+                    "source": "\n".join(lines),
+                })
+        return {
+            "found": True,
+            "file_path": file_path,
+            "symbol": None,
+            "kind": "module_constants",
+            "module_docstring": module_docstring,
+            "assignments": assignments,
+        }
+
+    # Walk all nodes to find functions inside classes too
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            continue
+        if node.name != symbol:
+            continue
+
+        kind = _node_kind(node)
+        docstring = ast.get_docstring(node) or None
+        lines = source_lines[node.lineno - 1 : node.end_lineno]
+
+        return {
+            "found": True,
+            "file_path": file_path,
+            "symbol": symbol,
+            "kind": kind,
+            "start_line": node.lineno,
+            "end_line": node.end_lineno,
+            "docstring": docstring,
+            "source": "\n".join(lines),
+        }
+
+    # Symbol not found — provide available symbol names as a hint
+    available = []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            available.append(node.name)
+
+    return {
+        "found": False,
+        "file_path": file_path,
+        "symbol": symbol,
+        "error": f"Symbol '{symbol}' not found in {file_path}",
+        "available_symbols": sorted(set(available)),
+        "hint": "Call get_signature(file_path) to see public symbols with line ranges.",
+    }