codegraph-nav 0.1.0__py3-none-any.whl

codegraph_nav/graph/query.py

@@ -0,0 +1,380 @@
+"""Graph queries — blast radius, change impact, risk scoring.
+
+All queries use parameterized SQL. Blast radius uses recursive CTEs for
+efficient transitive closure. Risk scoring adapts code-review-graph's
+proven 5-factor formula.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+from .schema import (
+    BATCH_SIZE,
+    MAX_IMPACT_DEPTH,
+    MAX_IMPACT_NODES,
+    SECURITY_KEYWORDS,
+)
+from .store import GraphStore
+
+# ==============================================================================
+# Blast Radius
+# ==============================================================================
+
+
+def get_blast_radius(
+    store: GraphStore,
+    changed_files: list[str],
+    max_depth: int = MAX_IMPACT_DEPTH,
+    max_nodes: int = MAX_IMPACT_NODES,
+) -> dict:
+    """Compute transitive impact of file changes using recursive CTE.
+
+    Returns dict with changed_nodes, impacted_nodes, impacted_files, etc.
+    """
+    if not changed_files:
+        return {
+            "changed_files": [],
+            "changed_nodes": 0,
+            "impacted_nodes": 0,
+            "impacted_files": [],
+            "direct_impacted": 0,
+            "transitive_impacted": 0,
+            "truncated": False,
+        }
+
+    conn = store.conn
+
+    # Seed: all nodes in changed files
+    placeholders = ",".join("?" for _ in changed_files)
+    seed_rows = conn.execute(
+        f"SELECT qualified_name FROM nodes WHERE file_path IN ({placeholders})",
+        changed_files,
+    ).fetchall()
+    seed_qns = {row[0] for row in seed_rows}
+
+    if not seed_qns:
+        return {
+            "changed_files": changed_files,
+            "changed_nodes": 0,
+            "impacted_nodes": 0,
+            "impacted_files": [],
+            "direct_impacted": 0,
+            "transitive_impacted": 0,
+            "truncated": False,
+        }
+
+    # Use temp table for seeds (avoids variable limit)
+    conn.execute("CREATE TEMP TABLE IF NOT EXISTS _blast_seeds (qn TEXT)")
+    conn.execute("DELETE FROM _blast_seeds")
+    seed_list = list(seed_qns)
+    for i in range(0, len(seed_list), BATCH_SIZE):
+        batch = [(qn,) for qn in seed_list[i : i + BATCH_SIZE]]
+        conn.executemany("INSERT INTO _blast_seeds (qn) VALUES (?)", batch)
+
+    # Recursive CTE: bidirectional BFS
+    rows = conn.execute(
+        """
+        WITH RECURSIVE impacted(node_qn, depth) AS (
+            SELECT qn, 0 FROM _blast_seeds
+            UNION
+            SELECT e.target_qualified, i.depth + 1
+            FROM impacted i
+            JOIN edges e ON e.source_qualified = i.node_qn
+            WHERE i.depth < ?
+            UNION
+            SELECT e.source_qualified, i.depth + 1
+            FROM impacted i
+            JOIN edges e ON e.target_qualified = i.node_qn
+            WHERE i.depth < ?
+        )
+        SELECT DISTINCT node_qn, MIN(depth) as min_depth
+        FROM impacted
+        GROUP BY node_qn
+        LIMIT ?
+        """,
+        (max_depth, max_depth, max_nodes),
+    ).fetchall()
+
+    conn.execute("DROP TABLE IF EXISTS _blast_seeds")
+
+    # Categorize
+    impacted_qns = {}
+    for row in rows:
+        impacted_qns[row[0]] = row[1]
+
+    # Get file paths for impacted nodes
+    all_qns = set(impacted_qns.keys())
+    impacted_nodes = store.batch_get_nodes(all_qns)
+    impacted_files = sorted({n["file_path"] for n in impacted_nodes} - set(changed_files))
+
+    direct = sum(1 for d in impacted_qns.values() if d == 1)
+    transitive = sum(1 for d in impacted_qns.values() if d > 1)
+
+    return {
+        "changed_files": changed_files,
+        "changed_nodes": len(seed_qns),
+        "impacted_nodes": len(impacted_qns) - len(seed_qns),
+        "impacted_files": impacted_files,
+        "direct_impacted": direct,
+        "transitive_impacted": transitive,
+        "truncated": len(rows) >= max_nodes,
+    }
+
+
+def format_blast_radius_minimal(result: dict) -> str:
+    """Format blast radius as compact string (<150 tokens)."""
+    files = result["changed_files"]
+    files_str = ", ".join(Path(f).name for f in files[:3])
+    if len(files) > 3:
+        files_str += f" +{len(files) - 3}"
+
+    lines = [
+        f"blast({files_str}): {result['impacted_nodes']} nodes · "
+        f"{len(result['impacted_files'])} files impacted"
+    ]
+
+    if result["impacted_files"]:
+        direct_files = result["impacted_files"][:5]
+        lines.append(f"  affected: {', '.join(Path(f).name for f in direct_files)}")
+        if len(result["impacted_files"]) > 5:
+            lines[-1] += f" +{len(result['impacted_files']) - 5} more"
+
+    if result["truncated"]:
+        lines.append("  (truncated)")
+
+    return "\n".join(lines)
+
+
+# ==============================================================================
+# Git Diff Parsing
+# ==============================================================================
+
+
+def parse_git_diff_ranges(
+    root_path: str,
+    base: str = "HEAD~1",
+) -> dict[str, list[tuple[int, int]]]:
+    """Parse git diff --unified=0 into changed line ranges per file.
+
+    Returns: {file_path: [(start_line, end_line), ...]}
+    """
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--unified=0", base, "--"],
+            cwd=root_path,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0:
+            return {}
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return {}
+
+    ranges: dict[str, list[tuple[int, int]]] = {}
+    current_file = None
+
+    for line in result.stdout.split("\n"):
+        if line.startswith("+++ b/"):
+            current_file = line[6:]
+        elif line.startswith("@@ ") and current_file:
+            # Parse hunk header: @@ -old,count +new,count @@
+            m = re.search(r"\+(\d+)(?:,(\d+))?", line)
+            if m:
+                start = int(m.group(1))
+                count = int(m.group(2)) if m.group(2) else 1
+                if count > 0:
+                    end = start + count - 1
+                    ranges.setdefault(current_file, []).append((start, end))
+
+    return ranges
+
+
+def map_changes_to_nodes(
+    store: GraphStore,
+    changed_ranges: dict[str, list[tuple[int, int]]],
+) -> list[dict]:
+    """Map changed line ranges to graph nodes.
+
+    Returns list of {"node": Row, "file": str, "risk": float}.
+    """
+    changed_nodes = []
+    for file_path, line_ranges in changed_ranges.items():
+        nodes = store.get_nodes_by_file(file_path)
+        for node in nodes:
+            if node["kind"] == "File":
+                continue
+            n_start = node["line_start"] or 0
+            n_end = node["line_end"] or n_start
+            for start, end in line_ranges:
+                if n_start <= end and n_end >= start:  # Overlap
+                    changed_nodes.append(
+                        {
+                            "node": node,
+                            "file": file_path,
+                            "risk": 0.0,
+                        }
+                    )
+                    break
+    return changed_nodes
+
+
+# ==============================================================================
+# Risk Scoring
+# ==============================================================================
+
+
+def compute_node_risk(store: GraphStore, node) -> float:
+    """Compute risk score (0.0-1.0) for a single node.
+
+    Factors:
+    - flow_membership:    min(count * 0.05, 0.25)
+    - cross_file_callers: min(count * 0.05, 0.15)
+    - untested:           0.30 if no TESTED_BY, else 0.05
+    - security_keyword:   0.20 if name matches
+    - caller_count:       min(count / 20, 0.10)
+    """
+    score = 0.0
+    qn = node["qualified_name"]
+
+    # 1. Flow membership
+    flow_count = store.count_flow_memberships(node["id"])
+    score += min(flow_count * 0.05, 0.25)
+
+    # 2. Cross-file callers
+    callers = store.get_edges_to(qn, kind="CALLS")
+    cross_file = sum(1 for e in callers if e["file_path"] != node["file_path"])
+    score += min(cross_file * 0.05, 0.15)
+
+    # 3. Test coverage
+    tested_by = store.get_edges_to(qn, kind="TESTED_BY")
+    score += 0.05 if tested_by else 0.30
+
+    # 4. Security keywords
+    name_lower = node["name"].lower()
+    qn_lower = qn.lower()
+    if any(kw in name_lower or kw in qn_lower for kw in SECURITY_KEYWORDS):
+        score += 0.20
+
+    # 5. Caller count
+    score += min(len(callers) / 20.0, 0.10)
+
+    return round(min(max(score, 0.0), 1.0), 4)
+
+
+def detect_changes(
+    store: GraphStore,
+    root_path: str,
+    base: str = "HEAD~1",
+) -> dict:
+    """Full change impact analysis: git diff → risk scores.
+
+    Returns dict with overall_risk, changed_nodes, test_gaps, affected_flows.
+    """
+    # Parse git diff
+    changed_ranges = parse_git_diff_ranges(root_path, base)
+    if not changed_ranges:
+        return {
+            "overall_risk": 0.0,
+            "risk_level": "NONE",
+            "changed_files": 0,
+            "changed_nodes": [],
+            "test_gaps": [],
+            "affected_flows": 0,
+        }
+
+    # Map to nodes
+    changed_nodes = map_changes_to_nodes(store, changed_ranges)
+
+    # Compute risk per node
+    for item in changed_nodes:
+        item["risk"] = compute_node_risk(store, item["node"])
+
+    # Sort by risk descending
+    changed_nodes.sort(key=lambda x: x["risk"], reverse=True)
+
+    # Overall risk = max node risk
+    overall_risk = max((n["risk"] for n in changed_nodes), default=0.0)
+
+    # Risk level
+    if overall_risk >= 0.7:
+        risk_level = "HIGH"
+    elif overall_risk >= 0.4:
+        risk_level = "MEDIUM"
+    elif overall_risk > 0:
+        risk_level = "LOW"
+    else:
+        risk_level = "NONE"
+
+    # Test gaps
+    test_gaps = []
+    for item in changed_nodes:
+        qn = item["node"]["qualified_name"]
+        tested_by = store.get_edges_to(qn, kind="TESTED_BY")
+        if not tested_by and item["node"]["kind"] in ("Function", "Method"):
+            test_gaps.append(item["node"]["name"])
+
+    # Affected flows
+    affected_flow_ids = set()
+    for item in changed_nodes:
+        memberships = store.get_flow_memberships(item["node"]["id"])
+        for m in memberships:
+            affected_flow_ids.add(m["flow_id"])
+
+    return {
+        "overall_risk": round(overall_risk, 4),
+        "risk_level": risk_level,
+        "changed_files": len(changed_ranges),
+        "changed_nodes": [
+            {
+                "name": item["node"]["name"],
+                "file": item["file"],
+                "risk": item["risk"],
+                "kind": item["node"]["kind"],
+            }
+            for item in changed_nodes
+        ],
+        "test_gaps": test_gaps,
+        "affected_flows": len(affected_flow_ids),
+    }
+
+
+def format_changes_minimal(result: dict) -> str:
+    """Format change impact as compact string (<100 tokens)."""
+    lines = [
+        f"risk: {result['overall_risk']:.2f} {result['risk_level']} | "
+        f"{result['changed_files']} files · {len(result['changed_nodes'])} symbols changed"
+    ]
+
+    # Group by file, show top risks
+    by_file: dict[str, list] = {}
+    for n in result["changed_nodes"]:
+        by_file.setdefault(n["file"], []).append(n)
+
+    for fpath, nodes in sorted(by_file.items(), key=lambda x: -max(n["risk"] for n in x[1])):
+        top_nodes = sorted(nodes, key=lambda x: -x["risk"])[:3]
+        node_strs = [f"{n['name']}({n['risk']:.2f})" for n in top_nodes]
+        level = (
+            "HIGH"
+            if top_nodes[0]["risk"] >= 0.7
+            else "MED" if top_nodes[0]["risk"] >= 0.4 else "LOW"
+        )
+        lines.append(f"  {level} {Path(fpath).name}: {', '.join(node_strs)}")
+        if len(lines) > 5:
+            lines.append(f"  ... +{len(by_file) - 4} more files")
+            break
+
+    if result["test_gaps"]:
+        gaps = result["test_gaps"][:5]
+        gaps_str = ", ".join(gaps)
+        if len(result["test_gaps"]) > 5:
+            gaps_str += f" +{len(result['test_gaps']) - 5}"
+        lines.append(f"  gaps: {gaps_str}")
+
+    if result["affected_flows"]:
+        lines.append(f"  flows: {result['affected_flows']} affected")
+
+    return "\n".join(lines)

codegraph_nav/graph/schema.py

@@ -0,0 +1,266 @@
+"""Graph database schema, migrations, and constants.
+
+Defines the SQLite schema for the optional graph layer (.codegraph.db).
+All tables use IF NOT EXISTS for safe re-creation. Migrations are applied
+incrementally via ensure_schema().
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+# ==============================================================================
+# Constants
+# ==============================================================================
+
+SCHEMA_VERSION = 4
+
+EDGE_KINDS = ("CALLS", "IMPORTS_FROM", "CONTAINS", "INHERITS", "TESTED_BY")
+NODE_KINDS = ("File", "Class", "Function", "Method", "Variable")
+
+SECURITY_KEYWORDS = frozenset(
+    {
+        "auth",
+        "login",
+        "password",
+        "token",
+        "session",
+        "crypt",
+        "secret",
+        "credential",
+        "permission",
+        "sql",
+        "query",
+        "execute",
+        "connect",
+        "socket",
+        "request",
+        "http",
+        "sanitize",
+        "validate",
+        "encrypt",
+        "decrypt",
+        "hash",
+        "sign",
+        "verify",
+        "admin",
+        "privilege",
+    }
+)
+
+MAX_IMPACT_DEPTH = 2
+MAX_IMPACT_NODES = 500
+MAX_BFS_DEPTH = 15
+BATCH_SIZE = 450  # Stay under SQLite's 999-variable limit
+
+# ==============================================================================
+# SQL DDL
+# ==============================================================================
+
+SQL_CREATE_NODES = """
+CREATE TABLE IF NOT EXISTS nodes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    kind TEXT NOT NULL,
+    name TEXT NOT NULL,
+    qualified_name TEXT NOT NULL UNIQUE,
+    file_path TEXT NOT NULL,
+    line_start INTEGER,
+    line_end INTEGER,
+    language TEXT,
+    parent_name TEXT,
+    signature TEXT,
+    is_test INTEGER DEFAULT 0,
+    file_hash TEXT,
+    extra TEXT DEFAULT '{}',
+    updated_at REAL NOT NULL
+)
+"""
+
+SQL_CREATE_EDGES = """
+CREATE TABLE IF NOT EXISTS edges (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    kind TEXT NOT NULL,
+    source_qualified TEXT NOT NULL,
+    target_qualified TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    extra TEXT DEFAULT '{}',
+    updated_at REAL NOT NULL
+)
+"""
+
+SQL_CREATE_METADATA = """
+CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+)
+"""
+
+SQL_CREATE_FLOWS = """
+CREATE TABLE IF NOT EXISTS flows (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    entry_point_id INTEGER NOT NULL,
+    depth INTEGER NOT NULL,
+    node_count INTEGER NOT NULL,
+    file_count INTEGER NOT NULL,
+    criticality REAL NOT NULL DEFAULT 0.0,
+    path_json TEXT NOT NULL,
+    updated_at REAL NOT NULL
+)
+"""
+
+SQL_CREATE_FLOW_MEMBERSHIPS = """
+CREATE TABLE IF NOT EXISTS flow_memberships (
+    flow_id INTEGER NOT NULL,
+    node_id INTEGER NOT NULL,
+    position INTEGER NOT NULL,
+    PRIMARY KEY (flow_id, node_id)
+)
+"""
+
+SQL_CREATE_INDEXES = [
+    "CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file_path)",
+    "CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind)",
+    "CREATE INDEX IF NOT EXISTS idx_nodes_qn ON nodes(qualified_name)",
+    "CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_qualified)",
+    "CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_qualified)",
+    "CREATE INDEX IF NOT EXISTS idx_edges_kind ON edges(kind)",
+    "CREATE INDEX IF NOT EXISTS idx_edges_file ON edges(file_path)",
+    "CREATE INDEX IF NOT EXISTS idx_flows_crit ON flows(criticality DESC)",
+]
+
+SQL_CREATE_FTS = """
+CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
+    name, qualified_name, file_path, signature,
+    tokenize='porter unicode61'
+)
+"""
+
+SQL_CREATE_COMMUNITIES = """
+CREATE TABLE IF NOT EXISTS communities (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    node_count INTEGER NOT NULL DEFAULT 0,
+    cohesion REAL NOT NULL DEFAULT 0.0,
+    file_prefix TEXT,
+    keywords TEXT DEFAULT '[]',
+    updated_at REAL NOT NULL
+)
+"""
+
+SQL_CREATE_COMMUNITY_MEMBERS = """
+CREATE TABLE IF NOT EXISTS community_members (
+    community_id INTEGER NOT NULL,
+    node_id INTEGER NOT NULL,
+    PRIMARY KEY (community_id, node_id)
+)
+"""
+
+SQL_CREATE_ROUTES = """
+CREATE TABLE IF NOT EXISTS routes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    method TEXT NOT NULL,
+    path TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    handler_name TEXT,
+    framework TEXT,
+    tags TEXT DEFAULT '[]',
+    confidence TEXT DEFAULT 'high',
+    updated_at REAL NOT NULL
+)
+"""
+
+SQL_CREATE_SCHEMAS = """
+CREATE TABLE IF NOT EXISTS schemas (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    orm TEXT,
+    fields TEXT DEFAULT '[]',
+    relations TEXT DEFAULT '[]',
+    updated_at REAL NOT NULL
+)
+"""
+
+SQL_CREATE_INDEXES_V4 = [
+    "CREATE INDEX IF NOT EXISTS idx_cm_community ON community_members(community_id)",
+    "CREATE INDEX IF NOT EXISTS idx_cm_node ON community_members(node_id)",
+    "CREATE INDEX IF NOT EXISTS idx_routes_file ON routes(file_path)",
+    "CREATE INDEX IF NOT EXISTS idx_schemas_file ON schemas(file_path)",
+]
+
+# ==============================================================================
+# Migrations
+# ==============================================================================
+
+MIGRATIONS = {
+    1: [
+        SQL_CREATE_NODES,
+        SQL_CREATE_EDGES,
+        SQL_CREATE_METADATA,
+        *SQL_CREATE_INDEXES[:7],  # Node + edge indexes
+    ],
+    2: [
+        SQL_CREATE_FLOWS,
+        SQL_CREATE_FLOW_MEMBERSHIPS,
+        SQL_CREATE_INDEXES[7],  # flows criticality index
+    ],
+    3: [
+        # FTS5 — may fail if not compiled in; that's OK
+    ],
+    4: [
+        SQL_CREATE_COMMUNITIES,
+        SQL_CREATE_COMMUNITY_MEMBERS,
+        SQL_CREATE_ROUTES,
+        SQL_CREATE_SCHEMAS,
+        *SQL_CREATE_INDEXES_V4,
+    ],
+}
+
+
+def ensure_schema(conn: sqlite3.Connection) -> int:
+    """Apply pending migrations. Returns current schema version."""
+    # Ensure metadata table exists first
+    conn.execute(SQL_CREATE_METADATA)
+
+    row = conn.execute("SELECT value FROM metadata WHERE key = 'schema_version'").fetchone()
+    current = int(row[0]) if row else 0
+
+    for version in sorted(MIGRATIONS.keys()):
+        if version <= current:
+            continue
+        for sql in MIGRATIONS[version]:
+            conn.execute(sql)
+
+        # Try FTS5 for version 3
+        if version == 3:
+            try:
+                conn.execute(SQL_CREATE_FTS)
+            except sqlite3.OperationalError:
+                pass  # FTS5 not available, skip
+
+        conn.execute(
+            "INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', ?)",
+            (str(version),),
+        )
+        conn.commit()
+
+    row = conn.execute("SELECT value FROM metadata WHERE key = 'schema_version'").fetchone()
+    return int(row[0]) if row else 0
+
+
+def make_qualified_name(file_path: str, name: str, parent: str | None = None) -> str:
+    """Build a qualified name: file_path::parent.name or file_path::name."""
+    if parent:
+        return f"{file_path}::{parent}.{name}"
+    return f"{file_path}::{name}"
+
+
+def is_fts5_available(conn: sqlite3.Connection) -> bool:
+    """Check if FTS5 is compiled into this SQLite build."""
+    try:
+        conn.execute("CREATE VIRTUAL TABLE IF NOT EXISTS _fts_probe USING fts5(x)")
+        conn.execute("DROP TABLE IF EXISTS _fts_probe")
+        return True
+    except sqlite3.OperationalError:
+        return False