codevira 1.6.0__py3-none-any.whl

mcp_server/migrate.py

@@ -0,0 +1,215 @@
+"""
+migrate.py — Legacy → Centralized storage migration for Codevira v1.6.
+
+Migrates per-project .codevira/ directories into ~/.codevira/projects/<key>/
+so that data lives centrally and no longer pollutes the project tree.
+
+Key behaviors:
+- Idempotent: safe to call multiple times; second call is a no-op.
+- Non-destructive: renames old .codevira/ to .codevira.migrated/ (not deleted).
+- SQLite-safe: uses sqlite3.Connection.backup() to copy WAL-mode databases.
+- Partial-migration recovery: if metadata.json is missing from centralized dir,
+  migration is re-run from scratch.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_CODEVIRA_VERSION = "1.6.0"
+
+
+def detect_migration_needed(project_root: Path) -> bool:
+    """Return True if the project has a legacy .codevira/ that needs migration.
+
+    Conditions:
+      - <project_root>/.codevira/config.yaml exists (legacy initialized project)
+      - No corresponding centralized dir with metadata.json exists yet
+    """
+    from mcp_server.paths import _sanitize_path_key, get_global_home
+
+    legacy = project_root / ".codevira"
+    if not (legacy / "config.yaml").is_file():
+        return False
+
+    key = _sanitize_path_key(project_root)
+    centralized = get_global_home() / "projects" / key
+    # Migration complete only if metadata.json is present
+    if (centralized / "metadata.json").is_file():
+        return False
+
+    return True
+
+
+def migrate_to_centralized(project_root: Path) -> dict:
+    """Migrate <project_root>/.codevira/ to ~/.codevira/projects/<key>/.
+
+    Returns a summary dict:
+      {migrated: True, files_copied: N, old_path: str, new_path: str}
+    or
+      {migrated: False, reason: str}
+
+    Migration steps:
+      1. Create centralized directory structure
+      2. Copy config.yaml and roadmap.yaml
+      3. Copy graph.db via sqlite3 backup API (WAL-safe)
+      4. Copy codeindex/ directory (ChromaDB persistent storage)
+      5. Write metadata.json
+      6. Update global.db project registry
+      7. Rename old .codevira/ → .codevira.migrated/ (safety net)
+    """
+    from mcp_server.paths import _sanitize_path_key, _get_git_remote_url, get_global_home, get_global_db_path
+
+    legacy = project_root / ".codevira"
+    if not (legacy / "config.yaml").is_file():
+        return {"migrated": False, "reason": "No legacy .codevira/config.yaml found"}
+
+    key = _sanitize_path_key(project_root)
+    centralized = get_global_home() / "projects" / key
+
+    # Already migrated?
+    if (centralized / "metadata.json").is_file():
+        return {"migrated": False, "reason": "Already migrated"}
+
+    logger.info("Migrating %s → %s", legacy, centralized)
+
+    # Create directory structure
+    (centralized / "graph" / "changesets").mkdir(parents=True, exist_ok=True)
+    (centralized / "codeindex").mkdir(parents=True, exist_ok=True)
+    (centralized / "logs").mkdir(parents=True, exist_ok=True)
+
+    files_copied = 0
+
+    # 1. Copy config.yaml
+    src_config = legacy / "config.yaml"
+    dst_config = centralized / "config.yaml"
+    shutil.copy2(src_config, dst_config)
+    files_copied += 1
+
+    # 2. Copy roadmap.yaml (may not exist)
+    src_roadmap = legacy / "roadmap.yaml"
+    if src_roadmap.exists():
+        shutil.copy2(src_roadmap, centralized / "roadmap.yaml")
+        files_copied += 1
+
+    # 3. Copy graph.db via sqlite3 backup API (safe under WAL mode)
+    src_db = legacy / "graph" / "graph.db"
+    dst_db = centralized / "graph" / "graph.db"
+    if src_db.exists():
+        src_conn = None
+        dst_conn = None
+        try:
+            src_conn = sqlite3.connect(str(src_db))
+            dst_conn = sqlite3.connect(str(dst_db))
+            src_conn.backup(dst_conn)
+            files_copied += 1
+        except Exception as e:
+            logger.warning("Could not backup graph.db via API, falling back to copy: %s", e)
+            # Fallback: copy main db + WAL/SHM files if present
+            shutil.copy2(src_db, dst_db)
+            for suffix in ("-wal", "-shm"):
+                wal_file = src_db.parent / (src_db.name + suffix)
+                if wal_file.exists():
+                    shutil.copy2(wal_file, dst_db.parent / (dst_db.name + suffix))
+            files_copied += 1
+        finally:
+            if src_conn:
+                src_conn.close()
+            if dst_conn:
+                dst_conn.close()
+
+    # 4. Copy codeindex/ (ChromaDB directory)
+    src_index = legacy / "codeindex"
+    dst_index = centralized / "codeindex"
+    if src_index.exists() and src_index.is_dir():
+        if dst_index.exists():
+            shutil.rmtree(dst_index)
+        shutil.copytree(src_index, dst_index)
+        files_copied += 1
+
+    # 5. Write metadata.json
+    git_remote = _get_git_remote_url(project_root)
+    metadata = {
+        "path_key": key,
+        "git_remote": git_remote,
+        "original_path": str(project_root),
+        "migrated_at": datetime.now(timezone.utc).isoformat(),
+        "version": _CODEVIRA_VERSION,
+    }
+    (centralized / "metadata.json").write_text(json.dumps(metadata, indent=2))
+
+    # 6. Update global.db project registry
+    gdb = None
+    try:
+        from indexer.global_db import GlobalDB
+        gdb = GlobalDB(get_global_db_path())
+        _ensure_git_remote_column(gdb)
+        gdb.register_project(
+            path=str(centralized),
+            name=project_root.name,
+            language="unknown",
+            git_remote=git_remote,
+        )
+    except Exception as e:
+        logger.warning("Could not update global.db during migration: %s", e)
+    finally:
+        if gdb is not None:
+            gdb.close()
+
+    # Invalidate the data-dir cache so get_data_dir() now returns the newly
+    # populated centralized directory, not the old legacy path.
+    try:
+        from mcp_server.paths import invalidate_data_dir_cache
+        invalidate_data_dir_cache(project_root)
+    except Exception:
+        pass  # Cache invalidation is best-effort; migration proceeds regardless
+
+    # 7. Rename old .codevira/ → .codevira.migrated/ (safety net, not deleted)
+    migrated_backup = project_root / ".codevira.migrated"
+    if migrated_backup.exists():
+        shutil.rmtree(migrated_backup)
+    legacy.rename(migrated_backup)
+
+    logger.info(
+        "Migration complete: %d files copied. Legacy dir renamed to %s",
+        files_copied,
+        migrated_backup,
+    )
+
+    return {
+        "migrated": True,
+        "files_copied": files_copied,
+        "old_path": str(legacy),
+        "new_path": str(centralized),
+    }
+
+
+def cleanup_legacy_dir(project_root: Path) -> bool:
+    """Remove the .codevira.migrated/ safety-net directory after confirmation.
+
+    Returns True if the directory was removed, False if it didn't exist.
+    Call only after verifying the migration was successful.
+    """
+    backup = project_root / ".codevira.migrated"
+    if backup.exists():
+        shutil.rmtree(backup)
+        logger.info("Removed legacy backup dir: %s", backup)
+        return True
+    return False
+
+
+def _ensure_git_remote_column(gdb) -> None:
+    """Add git_remote column to global_db.projects if not present (v1.6 schema upgrade)."""
+    try:
+        cols = [row[1] for row in gdb.conn.execute("PRAGMA table_info(projects)").fetchall()]
+        if "git_remote" not in cols:
+            gdb.conn.execute("ALTER TABLE projects ADD COLUMN git_remote TEXT")
+            gdb.conn.commit()
+    except Exception:
+        pass

mcp_server/paths.py

@@ -0,0 +1,256 @@
+"""
+paths.py — Centralized path resolution for Codevira.
+
+Resolution priority for get_data_dir():
+  1. Centralized ~/.codevira/projects/<key>/ — new in v1.6 (keyed by project path)
+  2. Git remote lookup — survives directory renames
+  3. Legacy <project_root>/.codevira/ — backward compat for existing projects
+  4. Default to centralized path for brand-new projects
+
+Project root discovery (get_project_root()):
+  - Uses --project-dir CLI override if set
+  - Walks upward from cwd looking for project markers:
+    .git, pyproject.toml, package.json, go.mod, Cargo.toml, .codevira/
+  - Falls back to cwd if no marker found
+
+Performance notes:
+  - get_data_dir() result is cached per project root (_data_dir_cache).
+    First call may spawn one `git remote` subprocess and scan metadata files;
+    every subsequent call for the same root is a dict lookup (~0µs).
+  - Call invalidate_data_dir_cache() after init/migration to force re-resolution.
+"""
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+from pathlib import Path
+
+# Allow overriding project directory via CLI flag (e.g. for Google Antigravity
+# which doesn't support the `cwd` option in its MCP config).
+_project_dir_override: Path | None = None
+
+
+def set_project_dir(path: str | Path) -> None:
+    """Override the project directory (called by CLI when --project-dir is passed).
+
+    Also clears the data-dir cache so subsequent get_data_dir() calls
+    resolve against the new project root, not a stale cached entry.
+    """
+    global _project_dir_override
+    _project_dir_override = Path(path).resolve()
+    invalidate_data_dir_cache()
+
+
+# ---------------------------------------------------------------------------
+# Path-key helpers (for centralized storage)
+# ---------------------------------------------------------------------------
+
+#: Markers that identify a project root when walking upward.
+_PROJECT_MARKERS = frozenset({
+    ".git",
+    "pyproject.toml",
+    "package.json",
+    "go.mod",
+    "Cargo.toml",
+    ".codevira",
+})
+
+
+def _sanitize_path_key(abs_path: str | Path) -> str:
+    """Convert an absolute path to a filesystem-safe key string.
+
+    Uses a short hash suffix to prevent collisions between paths that
+    differ only in separator characters (e.g. /foo-bar vs /foo/bar) or
+    drive letters (D:\\Projects\\Foo vs C:\\Projects\\Foo).
+
+    Examples:
+        /Users/sachin/Projects/Foo  → Users_sachin_Projects_Foo_a1b2c3d4
+        C:\\Users\\sachin\\Projects → Users_sachin_Projects_a1b2c3d4
+    """
+    import hashlib
+    resolved = str(Path(abs_path).resolve())
+    # Hash the FULL resolved path (before any lossy transforms) for uniqueness
+    path_hash = hashlib.sha256(resolved.encode()).hexdigest()[:8]
+    # Strip drive letter and leading separators for the human-readable part
+    stripped = re.sub(r"^[A-Za-z]:", "", resolved)  # Windows drive letter
+    stripped = stripped.lstrip("/\\")
+    # Replace path separators with underscores (not hyphens — preserves
+    # literal hyphens in directory names as distinct from separators)
+    key = re.sub(r"[/\\]", "_", stripped)
+    # Replace any remaining non-safe chars with hyphens
+    key = re.sub(r"[^a-zA-Z0-9._-]", "-", key)
+    # Collapse consecutive underscores/hyphens
+    key = re.sub(r"[_-]{2,}", "_", key)
+    key = key.strip("_-")
+    return f"{key}_{path_hash}"
+
+
+def _get_git_remote_url(project_root: Path) -> str | None:
+    """Return the git remote 'origin' URL for project_root, or None."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(project_root), "remote", "get-url", "origin"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        if result.returncode == 0:
+            url = result.stdout.strip()
+            return url if url else None
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        pass
+    return None
+
+
+def _find_project_by_git_remote(remote_url: str) -> Path | None:
+    """Scan ~/.codevira/projects/ for a project whose metadata.json matches remote_url."""
+    projects_dir = get_global_home() / "projects"
+    if not projects_dir.exists():
+        return None
+    for meta_file in projects_dir.glob("*/metadata.json"):
+        try:
+            meta = json.loads(meta_file.read_text())
+            if meta.get("git_remote") == remote_url:
+                # Return the centralized data dir (the directory containing metadata.json)
+                return meta_file.parent
+        except (json.JSONDecodeError, OSError):
+            continue
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Project root discovery
+# ---------------------------------------------------------------------------
+
+def _discover_project_root(start: Path) -> Path:
+    """Walk upward from *start* to find the nearest project root.
+
+    A project root is any ancestor directory that contains at least one
+    of: .git, pyproject.toml, package.json, go.mod, Cargo.toml, .codevira/
+
+    Stops at the first match so that nested repos return the inner root.
+    Falls back to *start* if no marker is found.
+    """
+    start = start.resolve()
+    for candidate in (start, *start.parents):
+        for marker in _PROJECT_MARKERS:
+            if (candidate / marker).exists():
+                return candidate
+    return start
+
+
+def get_project_root() -> Path:
+    """Return the project root directory.
+
+    Uses --project-dir override if set (for Google Antigravity),
+    otherwise falls back to the current working directory.
+    """
+    if _project_dir_override is not None:
+        return _discover_project_root(_project_dir_override)
+    return _discover_project_root(Path.cwd())
+
+
+# ---------------------------------------------------------------------------
+# Data directory resolution (v1.6 centralized + legacy fallback)
+# ---------------------------------------------------------------------------
+
+# ---------------------------------------------------------------------------
+# Data directory cache — avoids re-running subprocess + glob on every tool call.
+# Keyed by resolved project root Path.  Invalidated after init/migration.
+# ---------------------------------------------------------------------------
+_data_dir_cache: dict[Path, Path] = {}
+
+
+def invalidate_data_dir_cache(project_root: Path | None = None) -> None:
+    """Clear the data-dir cache so the next call re-resolves from disk.
+
+    Call this after codevira init or after a migration completes, when the
+    centralized directory has just been created and the cache entry would
+    still point to the old (non-existent) default path.
+
+    Args:
+        project_root: If given, only invalidate that project's entry.
+                      If None, clear the entire cache.
+    """
+    if project_root is None:
+        _data_dir_cache.clear()
+    else:
+        _data_dir_cache.pop(Path(project_root).resolve(), None)
+
+
+def get_data_dir() -> Path:
+    """Return the Codevira data directory for the current project.
+
+    Resolution chain (run once per project root, then cached):
+      1. Centralized ~/.codevira/projects/<key>/ if config.yaml exists there
+      2. Git remote lookup — finds centralized dir even after directory rename
+      3. Legacy <project_root>/.codevira/ if config.yaml exists there
+      4. Default to centralized path (new projects land here automatically)
+
+    After the first call for a given project root the result is cached in
+    _data_dir_cache.  Subsequent calls are O(1) dict lookups with no I/O.
+    Call invalidate_data_dir_cache() after init or migration to force refresh.
+    """
+    project_root = get_project_root()
+
+    # Fast path — already resolved for this root
+    if project_root in _data_dir_cache:
+        return _data_dir_cache[project_root]
+
+    result = _resolve_data_dir(project_root)
+    _data_dir_cache[project_root] = result
+    return result
+
+
+def _resolve_data_dir(project_root: Path) -> Path:
+    """Perform the actual (potentially slow) data-dir resolution.
+
+    This is the only place that spawns subprocesses or reads metadata files.
+    Always call get_data_dir() in production code — it caches this result.
+    """
+    key = _sanitize_path_key(project_root)
+    centralized = get_global_home() / "projects" / key
+
+    # 1. Centralized dir already initialized?
+    if (centralized / "config.yaml").is_file():
+        return centralized
+
+    # 2. Try git remote lookup (survives directory renames).
+    #    _get_git_remote_url() and _find_project_by_git_remote() are the
+    #    potentially expensive operations — subprocess + metadata file scan.
+    #    They only run once per project root thanks to the cache above.
+    remote_url = _get_git_remote_url(project_root)
+    if remote_url:
+        found = _find_project_by_git_remote(remote_url)
+        if found is not None:
+            return found
+
+    # 3. Legacy in-project .codevira/ (backward compat for v1.5 and earlier)
+    legacy = project_root / ".codevira"
+    if (legacy / "config.yaml").is_file():
+        return legacy
+
+    # 4. Default to centralized path — new project, will be created on init
+    return centralized
+
+
+def get_package_data_dir() -> Path:
+    """Return the bundled data directory that ships with the pip package.
+
+    Contains: rules/, agents/, config.example.yaml
+    These are read-only assets installed alongside the package.
+    """
+    return Path(__file__).parent / "data"
+
+
+def get_global_home() -> Path:
+    """Return ~/.codevira/ global data directory. Creates it if needed."""
+    home = Path.home() / ".codevira"
+    home.mkdir(parents=True, exist_ok=True)
+    return home
+
+
+def get_global_db_path() -> Path:
+    """Return path to the global SQLite database for cross-project intelligence."""
+    return get_global_home() / "global.db"

mcp_server/prompts.py

@@ -0,0 +1,136 @@
+"""
+prompts.py — MCP workflow prompt templates.
+
+Five pre-built prompts that give AI agents structured starting points
+for common workflows: review, debug, onboard, pre-commit, and architecture.
+"""
+from __future__ import annotations
+
+PROMPTS = {
+    "review_changes": {
+        "name": "review_changes",
+        "description": "Review current changes with risk analysis, test coverage gaps, and learned rules.",
+        "arguments": [
+            {"name": "base_ref", "description": "Base git ref to diff against (default: main)", "required": False},
+        ],
+        "template": (
+            "Review the current code changes for quality, risks, and missed tests.\n\n"
+            "Steps:\n"
+            "1. Call analyze_changes() to get function-level risk scores and test coverage gaps.\n"
+            "2. Call get_learned_rules() to check if any changes violate learned patterns.\n"
+            "3. Call get_preferences() to verify the changes match the developer's coding style.\n"
+            "4. For each HIGH risk change, call query_graph() to understand callers and downstream impact.\n\n"
+            "Present a structured review with:\n"
+            "- Risk summary (high/medium/low changes)\n"
+            "- Test coverage gaps\n"
+            "- Style violations\n"
+            "- Suggested improvements"
+        ),
+    },
+    "debug_issue": {
+        "name": "debug_issue",
+        "description": "Debug an issue by tracing code paths, searching past decisions, and checking confidence.",
+        "arguments": [
+            {"name": "description", "description": "Description of the issue to debug", "required": True},
+        ],
+        "template": (
+            "Debug the following issue: {description}\n\n"
+            "Steps:\n"
+            "1. Call search_codebase() with the issue description to find relevant code.\n"
+            "2. Call query_graph() on the most relevant files to trace callers and callees.\n"
+            "3. Call search_decisions() to check if similar issues were addressed before.\n"
+            "4. Call get_decision_confidence() on affected files to check if this is an ambiguous area.\n"
+            "5. Call get_impact() on the likely source file to understand blast radius.\n\n"
+            "Present:\n"
+            "- Most likely root cause with evidence\n"
+            "- Affected code paths\n"
+            "- Past decisions that relate to this area\n"
+            "- Recommended fix approach"
+        ),
+    },
+    "onboard_session": {
+        "name": "onboard_session",
+        "description": "Start a new coding session with full context — roadmap, open work, rules, and recent history.",
+        "arguments": [],
+        "template": (
+            "Orient to this project and prepare for a productive coding session.\n\n"
+            "Steps:\n"
+            "1. Call get_session_context() for a complete catch-up: roadmap phase, open changesets, "
+            "recent decisions, confidence scores, preferences, and learned rules.\n"
+            "2. Call list_open_changesets() to check for interrupted multi-file work.\n"
+            "3. Call get_project_maturity() to understand overall project intelligence level.\n\n"
+            "Present a concise session briefing:\n"
+            "- Current project phase and next action\n"
+            "- Any open changesets that need resuming\n"
+            "- Key rules and preferences to follow\n"
+            "- Areas of low confidence that need extra care"
+        ),
+    },
+    "pre_commit_check": {
+        "name": "pre_commit_check",
+        "description": "Pre-commit review — check staged changes for risks and missing tests.",
+        "arguments": [],
+        "template": (
+            "Review the staged changes before committing.\n\n"
+            "Steps:\n"
+            "1. Call analyze_changes(base_ref='HEAD') to review staged changes at function level.\n"
+            "2. Call find_hotspots() to check if any modified functions are complexity hotspots.\n"
+            "3. Call get_learned_rules() to verify no patterns are violated.\n\n"
+            "Present:\n"
+            "- Changes summary with risk scores\n"
+            "- Missing test coverage\n"
+            "- Hotspot warnings (large functions, high fan-in)\n"
+            "- Go/no-go recommendation"
+        ),
+    },
+    "architecture_overview": {
+        "name": "architecture_overview",
+        "description": "Show project architecture — dependency graph, layers, hotspots, and maturity.",
+        "arguments": [],
+        "template": (
+            "Generate an architecture overview of this project.\n\n"
+            "Steps:\n"
+            "1. Call export_graph(format='mermaid') to generate a dependency diagram.\n"
+            "2. Call list_nodes() to see all files organized by layer.\n"
+            "3. Call find_hotspots() to identify complexity and risk areas.\n"
+            "4. Call get_project_maturity() for overall intelligence metrics.\n\n"
+            "Present:\n"
+            "- Dependency diagram (Mermaid)\n"
+            "- Layer breakdown (API, service, database, utility, test)\n"
+            "- Hotspots and risk areas\n"
+            "- Maturity score and what it means"
+        ),
+    },
+}
+
+
+def list_prompts() -> list[dict]:
+    """Return all available prompts for MCP list_prompts()."""
+    return [
+        {
+            "name": p["name"],
+            "description": p["description"],
+            "arguments": p.get("arguments", []),
+        }
+        for p in PROMPTS.values()
+    ]
+
+
+def get_prompt(name: str, arguments: dict | None = None) -> dict | None:
+    """Return a prompt template with arguments substituted."""
+    prompt = PROMPTS.get(name)
+    if not prompt:
+        return None
+
+    template = prompt["template"]
+    if arguments:
+        for key, value in arguments.items():
+            template = template.replace(f"{{{key}}}", str(value))
+
+    return {
+        "name": prompt["name"],
+        "description": prompt["description"],
+        "messages": [
+            {"role": "user", "content": {"type": "text", "text": template}},
+        ],
+    }