ucm-mcp 0.1.0__tar.gz

ucm_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: ucm-mcp
+Version: 0.1.0
+Summary: Universal Code Mapper - MCP server for AI-agent code navigation
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.139.0
+Requires-Dist: fastmcp>=3.4.3
+Requires-Dist: mcp[cli]>=1.0
+Requires-Dist: pathspec
+Requires-Dist: pydantic>=2
+Requires-Dist: tree-sitter-language-pack
+Requires-Dist: tree-sitter>=0.21
+Requires-Dist: watchfiles

ucm_mcp-0.1.0/README.md

@@ -0,0 +1,105 @@
+# Universal Code Mapper (UCM) MCP Server
+
+UCM is a fast, offline, Universal Code Mapper exposed as a [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server. It enables AI coding assistants (like Claude) to navigate, search, and understand your codebases structurally without relying on embeddings or cloud AI dependencies.
+
+## ✨ Features
+
+- **Blazing Fast**: Uses `tree-sitter` for rapid parsing and SQLite FTS5 for full-text search. No embeddings!
+- **Interactive Web UI**: Comes with a built-in network graph visualization to explore your codebase map in the browser.
+- **Call Graphs & Relationships**: Traverse callers, callees, inheritance, and dependencies.
+- **Framework Aware**: Extensively extracts routes and architectural heuristics for Django and React.
+- **Incremental Indexing**: Instant re-indexing of unchanged files using `mtime` and content hashing.
+- **Agent-Optimized Tools**: Designed specifically for LLMs to easily understand project architecture, route maps, and dead code.
+
+---
+
+## 📦 Installation
+
+UCM can be installed directly from PyPI. We recommend using [`uv`](https://github.com/astral-sh/uv) for the fastest installation and execution:
+
+```bash
+uv tool install ucm-mcp
+```
+
+Or using standard `pip`:
+
+```bash
+pip install ucm-mcp
+```
+
+---
+
+## 🚀 Quickstart
+
+### 1. The Interactive Web UI
+
+UCM comes with a rich, interactive web UI to visualize your codebase architecture, view full network graphs, and run architectural analysis. 
+
+When you run UCM, the visualizer UI is automatically served in the background!
+
+```bash
+uvx ucm-mcp
+# Or if installed globally:
+# ucm-mcp
+```
+
+Upon startup, you will see a banner in your terminal:
+```text
+============================================================
+🚀 UCM Backend is running!
+🌐 Open the UI at: https://ucm-ui.netlify.app/?port=8000
+============================================================
+```
+Click the link to open the Visualizer UI, which will automatically connect to your local backend.
+
+### 2. Setting up in Claude Desktop (MCP Client)
+
+To give Claude (or any other MCP-compatible AI assistant) access to your codebase architecture, add UCM to your MCP client configuration.
+
+**For Claude Desktop (`claude_desktop_config.json`):**
+
+```json
+{
+  "mcpServers": {
+    "ucm": {
+      "command": "uvx",
+      "args": [
+        "ucm-mcp"
+      ]
+    }
+  }
+}
+```
+
+*Note: Even when running inside Claude, the background Web UI will still be active and available to you via the browser!*
+
+---
+
+## 🛠️ Usage & Tools
+
+Once connected, your AI assistant will have access to a powerful suite of tools to understand your code. 
+
+**First Step:**
+- `ucm_index_project`: Indexes the specified directory. This **must** be called before queries work. (The UI can also trigger this index!)
+
+**Exploration Tools:**
+- `ucm_search_symbol` / `ucm_search_keywords`: Powerful search over AST symbols and full-text code.
+- `ucm_file_map` / `ucm_directory_map`: View the hierarchical layout of the project.
+- `ucm_get_symbol_info`: Retrieve detailed AST information about a specific class, function, or method.
+
+**Analysis Tools:**
+- `ucm_find_callers` / `ucm_find_callees`: Trace execution paths and function calls.
+- `ucm_impact_analysis`: Check what breaks when a specific function or class is modified.
+- `ucm_architecture_summary`: Automatically generates a high-level overview of the project structure.
+- `ucm_route_lookup`: Automatically extracts web framework routes (e.g., Django, React).
+- `ucm_dead_code_detection`: Identifies unused functions and classes.
+
+---
+
+## ⚙️ Advanced Configuration
+
+You can customize the UCM server using the following CLI arguments:
+
+- `--port <PORT>`: Change the default port (8000) for the UI server.
+- `--http`: Run exclusively in HTTP (SSE) mode instead of standard MCP stdio.
+- `--data-dir <PATH>`: Override the default SQLite storage location (defaults to `~/.ucm`).

ucm_mcp-0.1.0/eval.xml

@@ -0,0 +1,10 @@
+<evaluation>
+   <qa_pair>
+      <question>Search for a symbol named 'FastMCP' in the project 'd:\DEV\mcp\Code-Mapper\ucm-mcp'. Set this path as the active project first using ucm_set_active_project, then use ucm_search_symbol. Wait, you must index the project first using ucm_index_project. What is the line number where 'FastMCP' is imported or defined in src\ucm_mcp\server.py according to the search results?</question>
+      <answer>2</answer>
+   </qa_pair>
+   <qa_pair>
+      <question>In the active project 'd:\DEV\mcp\Code-Mapper\ucm-mcp', use ucm_search_symbol to find the symbol 'ucm_search_keywords'. What file path (relative to the project root, like src\...) is it located in?</question>
+      <answer>src\ucm_mcp\tools\search_tools.py</answer>
+   </qa_pair>
+</evaluation>

ucm_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "ucm-mcp"
+version = "0.1.0"
+description = "Universal Code Mapper - MCP server for AI-agent code navigation"
+requires-python = ">=3.11"
+dependencies = [
+    "mcp[cli]>=1.0",
+    "pydantic>=2",
+    "tree-sitter>=0.21",
+    "tree-sitter-language-pack",
+    "watchfiles",
+    "pathspec",
+    "fastapi>=0.139.0",
+    "fastmcp>=3.4.3",
+]
+
+[project.scripts]
+ucm-mcp = "ucm_mcp.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ucm_mcp"]

ucm_mcp-0.1.0/src/ucm_mcp/analysis/dead_code.py

@@ -0,0 +1,48 @@
+from typing import List, Dict, Any
+from ucm_mcp.db.connection import get_connection
+
+def find_dead_code(db_id: str, symbol_types: List[str] | None, data_dir: str | None = None) -> List[Dict[str, Any]]:
+    conn = get_connection(db_id, data_dir)
+    cur = conn.cursor()
+    
+    # We find symbols that never appear as a callee_name in `calls`
+    # and maybe filter by symbol_types (like ['function', 'method'])
+    
+    sql = '''
+        SELECT s.name, s.type, f.path, s.line
+        FROM symbols s
+        JOIN files f ON s.file_id = f.id
+        WHERE s.name NOT IN (SELECT callee_name FROM calls)
+        AND s.id NOT IN (SELECT handler_symbol_id FROM routes WHERE handler_symbol_id IS NOT NULL)
+    '''
+    params = []
+    
+    if symbol_types:
+        placeholders = ",".join("?" for _ in symbol_types)
+        sql += f" AND s.type IN ({placeholders})"
+        params.extend(symbol_types)
+        
+    # Also ignore standard dunder methods in Python, etc.
+    sql += " AND s.name NOT LIKE '\\_\\_%' ESCAPE '\\'"
+    
+    # Ignore test functions
+    sql += " AND s.name NOT LIKE 'test_%'"
+    
+    # Ignore controllers (often implicitly instantiated by frameworks)
+    sql += " AND s.name NOT LIKE '%Controller%'"
+    sql += " AND s.name NOT LIKE '%controller%'"
+    
+    sql += " ORDER BY f.path, s.line"
+    
+    cur.execute(sql, tuple(params))
+    
+    results = []
+    for row in cur.fetchall():
+        results.append({
+            "name": row["name"],
+            "type": row["type"],
+            "path": row["path"],
+            "line": row["line"]
+        })
+        
+    return results

ucm_mcp-0.1.0/src/ucm_mcp/analysis/export.py

@@ -0,0 +1,152 @@
+from typing import Dict, Any, Optional, List
+from pydantic import BaseModel
+from ucm_mcp.db.connection import get_connection
+
+class Node(BaseModel):
+    id: str
+    type: str
+    label: str
+    parent: Optional[str] = None
+    language: Optional[str] = None
+    symbol_type: Optional[str] = None
+    line: Optional[int] = None
+    framework: Optional[str] = None
+
+class Edge(BaseModel):
+    id: str
+    source: str
+    target: str
+    type: str
+    label: Optional[str] = None
+
+class GraphData(BaseModel):
+    nodes: List[Node]
+    edges: List[Edge]
+
+def get_full_graph(db_id: str, data_dir: Optional[str] = None) -> GraphData:
+    conn = get_connection(db_id, data_dir)
+    cur = conn.cursor()
+    
+    cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='files'")
+    if not cur.fetchone():
+        raise ValueError("Project not indexed")
+
+    
+    nodes: List[Node] = []
+    edges: List[Edge] = []
+    
+    # 1. Add a central root node for the project
+    nodes.append(Node(id="dir_root", type="dir", label="Project Root", parent=None))
+    
+    # 2. Get all files and build directory nodes
+    cur.execute("SELECT id, path, language FROM files")
+    files = cur.fetchall()
+    seen_dirs = {"dir_root"}
+    
+    for f in files:
+        path = f['path']
+        parts = path.split('/')
+        file_name = parts[-1]
+        
+        parent_id = "dir_root"
+        current_dir_path = ""
+        for i in range(len(parts) - 1):
+            part = parts[i]
+            if current_dir_path:
+                current_dir_path += f"/{part}"
+            else:
+                current_dir_path = part
+                
+            dir_id = f"dir_{current_dir_path}"
+            if dir_id not in seen_dirs:
+                seen_dirs.add(dir_id)
+                nodes.append(Node(
+                    id=dir_id,
+                    type="dir",
+                    label=part,
+                    parent=parent_id
+                ))
+            parent_id = dir_id
+
+        nodes.append(Node(
+            id=f"file_{f['id']}",
+            type="file",
+            label=file_name,
+            language=f['language'],
+            parent=parent_id
+        ))
+        
+    # 2. Get all symbols
+    cur.execute("SELECT id, file_id, type, name, line FROM symbols")
+    symbols = cur.fetchall()
+    for s in symbols:
+        nodes.append(Node(
+            id=f"sym_{s['id']}",
+            type="symbol",
+            label=s['name'],
+            symbol_type=s['type'],
+            line=s['line'],
+            parent=f"file_{s['file_id']}"
+        ))
+        
+    # 3. Get all routes
+    cur.execute("""
+        SELECT r.id, r.method, r.path, r.handler_symbol_id, r.framework, s.file_id 
+        FROM routes r
+        LEFT JOIN symbols s ON r.handler_symbol_id = s.id
+    """)
+    routes = cur.fetchall()
+    for r in routes:
+        parent_id = f"file_{r['file_id']}" if r['file_id'] else None
+        nodes.append(Node(
+            id=f"route_{r['id']}",
+            type="route",
+            label=f"{r['method']} {r['path']}",
+            framework=r['framework'],
+            parent=parent_id
+        ))
+        # Edge: Route -> Handler
+        if r['handler_symbol_id']:
+            edges.append(Edge(
+                id=f"edge_r2h_{r['id']}",
+                source=f"route_{r['id']}",
+                target=f"sym_{r['handler_symbol_id']}",
+                type="handled_by"
+            ))
+            
+    # 4. Get all imports (File -> File)
+    cur.execute("SELECT id, from_file_id, resolved_file_id, to_module FROM imports WHERE resolved_file_id IS NOT NULL")
+    imports = cur.fetchall()
+    for i in imports:
+        edges.append(Edge(
+            id=f"edge_imp_{i['id']}",
+            source=f"file_{i['from_file_id']}",
+            target=f"file_{i['resolved_file_id']}",
+            type="imports",
+            label=i['to_module']
+        ))
+        
+    # 5. Get all calls (Symbol -> Symbol)
+    cur.execute("SELECT id, caller_symbol_id, callee_symbol_id, callee_name FROM calls WHERE callee_symbol_id IS NOT NULL")
+    calls = cur.fetchall()
+    for c in calls:
+        edges.append(Edge(
+            id=f"edge_call_{c['id']}",
+            source=f"sym_{c['caller_symbol_id']}",
+            target=f"sym_{c['callee_symbol_id']}",
+            type="calls",
+            label=c['callee_name']
+        ))
+        
+    # 6. Get all inheritance
+    cur.execute("SELECT id, child_symbol_id, parent_symbol_id, kind FROM inheritance WHERE parent_symbol_id IS NOT NULL")
+    inheritances = cur.fetchall()
+    for ih in inheritances:
+        edges.append(Edge(
+            id=f"edge_inh_{ih['id']}",
+            source=f"sym_{ih['child_symbol_id']}",
+            target=f"sym_{ih['parent_symbol_id']}",
+            type=ih['kind']
+        ))
+        
+    return GraphData(nodes=nodes, edges=edges)

ucm_mcp-0.1.0/src/ucm_mcp/analysis/impact.py

@@ -0,0 +1,37 @@
+from typing import List, Dict, Any, Set
+from ucm_mcp.db.connection import get_connection
+
+def calculate_impact(db_id: str, symbol_name: str, depth: int, data_dir: str | None = None) -> List[Dict[str, Any]]:
+    conn = get_connection(db_id, data_dir)
+    cur = conn.cursor()
+    
+    # We find all symbols that call this symbol (directly or indirectly) up to 'depth' levels.
+    # Because we don't have a CTE (Common Table Expression) for recursion easily accessible if we just want simple Python logic,
+    # we can do it iteratively.
+    
+    affected_symbols = set()
+    current_level_names = {symbol_name}
+    
+    for _ in range(depth):
+        if not current_level_names:
+            break
+            
+        placeholders = ",".join("?" for _ in current_level_names)
+        cur.execute(f'''
+            SELECT s.name, s.type, f.path
+            FROM calls c
+            JOIN symbols s ON c.caller_symbol_id = s.id
+            JOIN files f ON s.file_id = f.id
+            WHERE c.callee_name IN ({placeholders})
+        ''', list(current_level_names))
+        
+        next_level = set()
+        for row in cur.fetchall():
+            sym_desc = f"{row['type']} {row['name']} ({row['path']})"
+            if sym_desc not in affected_symbols:
+                affected_symbols.add(sym_desc)
+                next_level.add(row['name'])
+                
+        current_level_names = next_level
+        
+    return list(affected_symbols)

ucm_mcp-0.1.0/src/ucm_mcp/cli.py

@@ -0,0 +1,48 @@
+import os
+import sys
+import argparse
+import threading
+import uvicorn
+import asyncio
+
+def run_uvicorn(port: int):
+    # Run uvicorn with logging disabled to avoid interfering with MCP stdio
+    config = uvicorn.Config(
+        "ucm_mcp.main:app",
+        host="127.0.0.1",
+        port=port,
+        log_level="error",
+        access_log=False,
+    )
+    server = uvicorn.Server(config)
+    try:
+        asyncio.run(server.serve())
+    except Exception:
+        pass
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="ucm-mcp")
+    parser.add_argument("--http", action="store_true", help="Use streamable HTTP transport instead of stdio")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--data-dir", default=None, help="Override ~/.ucm storage location")
+    args = parser.parse_args()
+
+    # Set env vars before importing main
+    if args.data_dir:
+        os.environ["UCM_DATA_DIR"] = args.data_dir
+    os.environ["UCM_PORT"] = str(args.port)
+
+    # Import mcp from main after setting env vars
+    from ucm_mcp.main import mcp
+
+    if args.http:
+        # Run natively in the main thread (allows logs)
+        uvicorn.run("ucm_mcp.main:app", host="127.0.0.1", port=args.port)
+    else:
+        # Run stdio in main thread, run UI http server in background
+        t = threading.Thread(target=run_uvicorn, args=(args.port,), daemon=True)
+        t.start()
+        mcp.run()
+
+if __name__ == "__main__":
+    main()

ucm_mcp-0.1.0/src/ucm_mcp/config.py

@@ -0,0 +1,8 @@
+import os
+from pathlib import Path
+
+def get_base_dir(data_dir: str | None = None) -> Path:
+    """Return the base directory for UCM storage (~/.ucm)."""
+    if data_dir:
+        return Path(data_dir).resolve()
+    return Path.home() / ".ucm"

ucm_mcp-0.1.0/src/ucm_mcp/db/connection.py

@@ -0,0 +1,52 @@
+import sqlite3
+from collections import OrderedDict
+from pathlib import Path
+
+from ucm_mcp.config import get_base_dir
+
+class ConnectionCache:
+    def __init__(self, maxsize: int = 20):
+        self.maxsize = maxsize
+        self._cache: OrderedDict[str, sqlite3.Connection] = OrderedDict()
+
+    def get_connection(self, db_id: str, data_dir: str | None = None) -> sqlite3.Connection:
+        if db_id in self._cache:
+            self._cache.move_to_end(db_id)
+            return self._cache[db_id]
+            
+        base_dir = get_base_dir(data_dir)
+        project_dir = base_dir / "projects" / db_id
+        project_dir.mkdir(parents=True, exist_ok=True)
+        
+        db_path = project_dir / "index.sqlite3"
+        print(f"Db path from connection.py: {db_path}")
+        conn = sqlite3.connect(db_path, check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        
+        # Initialize schema if new
+        self._init_schema(conn)
+        
+        self._cache[db_id] = conn
+        if len(self._cache) > self.maxsize:
+            _, old_conn = self._cache.popitem(last=False)
+            old_conn.close()
+            
+        return conn
+
+    def _init_schema(self, conn: sqlite3.Connection) -> None:
+        schema_path = Path(__file__).parent / "schema.sql"
+        if schema_path.exists():
+            with open(schema_path, "r", encoding="utf-8") as f:
+                schema = f.read()
+            conn.executescript(schema)
+            conn.commit()
+
+    def close_all(self):
+        for conn in self._cache.values():
+            conn.close()
+        self._cache.clear()
+
+_connection_cache = ConnectionCache()
+
+def get_connection(db_id: str, data_dir: str | None = None) -> sqlite3.Connection:
+    return _connection_cache.get_connection(db_id, data_dir)

ucm_mcp-0.1.0/src/ucm_mcp/db/registry_schema.sql

@@ -0,0 +1,8 @@
+CREATE TABLE IF NOT EXISTS projects (
+    db_id TEXT PRIMARY KEY,
+    canonical_path TEXT UNIQUE NOT NULL,
+    first_indexed_at REAL NOT NULL,
+    last_indexed_at REAL,
+    file_count INTEGER DEFAULT 0,
+    symbol_count INTEGER DEFAULT 0
+);

ucm_mcp-0.1.0/src/ucm_mcp/db/repository.py

@@ -0,0 +1,58 @@
+import sqlite3
+from typing import TypedDict, List
+from ucm_mcp.db.connection import get_connection
+
+class FileRecord(TypedDict):
+    id: int
+    path: str
+    language: str | None
+    hash: str
+    size: int
+    mtime: float
+
+def insert_or_update_file(db_id: str, path: str, language: str | None, file_hash: str, size: int, mtime: float, data_dir: str | None = None) -> tuple[int, bool]:
+    conn = get_connection(db_id, data_dir)
+    cur = conn.cursor()
+    
+    cur.execute("SELECT id, hash FROM files WHERE path = ?", (path,))
+    row = cur.fetchone()
+    
+    is_changed = True
+    if row:
+        file_id = row["id"]
+        old_hash = row["hash"]
+        if old_hash == file_hash:
+            is_changed = False
+            
+        cur.execute(
+            """UPDATE files SET language = ?, hash = ?, size = ?, mtime = ? WHERE id = ?""",
+            (language, file_hash, size, mtime, file_id)
+        )
+    else:
+        cur.execute(
+            """INSERT INTO files (path, language, hash, size, mtime) VALUES (?, ?, ?, ?, ?)""",
+            (path, language, file_hash, size, mtime)
+        )
+        file_id = cur.lastrowid
+        
+    conn.commit()
+    assert file_id is not None
+    return file_id, is_changed
+
+def get_file_counts(db_id: str, data_dir: str | None = None) -> dict[str, int]:
+    conn = get_connection(db_id, data_dir)
+    cur = conn.cursor()
+    cur.execute("SELECT language, COUNT(*) as count FROM files GROUP BY language")
+    rows = cur.fetchall()
+    
+    result = {}
+    for row in rows:
+        lang = row["language"] or "unknown"
+        result[lang] = row["count"]
+    return result
+
+def get_total_file_count(db_id: str, data_dir: str | None = None) -> int:
+    conn = get_connection(db_id, data_dir)
+    cur = conn.cursor()
+    cur.execute("SELECT COUNT(*) as c FROM files")
+    return cur.fetchone()["c"]

ucm_mcp-0.1.0/src/ucm_mcp/db/schema.sql

@@ -0,0 +1,86 @@
+CREATE TABLE IF NOT EXISTS files (
+    id INTEGER PRIMARY KEY,
+    path TEXT UNIQUE NOT NULL,
+    language TEXT,
+    hash TEXT NOT NULL,
+    size INTEGER NOT NULL,
+    mtime REAL NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS symbols (
+    id INTEGER PRIMARY KEY,
+    file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    type TEXT NOT NULL,          
+    name TEXT NOT NULL,
+    parent_id INTEGER REFERENCES symbols(id),
+    visibility TEXT,
+    line INTEGER NOT NULL,
+    column INTEGER NOT NULL,
+    signature TEXT,
+    docstring TEXT,
+    summary TEXT
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(
+    name, docstring, summary,
+    content='symbols', content_rowid='id',
+    tokenize='unicode61 remove_diacritics 1'
+);
+
+CREATE TRIGGER IF NOT EXISTS symbols_ai AFTER INSERT ON symbols BEGIN
+  INSERT INTO symbols_fts(rowid, name, docstring, summary) VALUES (new.id, new.name, new.docstring, new.summary);
+END;
+CREATE TRIGGER IF NOT EXISTS symbols_ad AFTER DELETE ON symbols BEGIN
+  INSERT INTO symbols_fts(symbols_fts, rowid, name, docstring, summary) VALUES ('delete', old.id, old.name, old.docstring, old.summary);
+END;
+CREATE TRIGGER IF NOT EXISTS symbols_au AFTER UPDATE ON symbols BEGIN
+  INSERT INTO symbols_fts(symbols_fts, rowid, name, docstring, summary) VALUES ('delete', old.id, old.name, old.docstring, old.summary);
+  INSERT INTO symbols_fts(rowid, name, docstring, summary) VALUES (new.id, new.name, new.docstring, new.summary);
+END;
+
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_id);
+
+CREATE TABLE IF NOT EXISTS imports (
+    id INTEGER PRIMARY KEY,
+    from_file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    to_module TEXT NOT NULL,
+    resolved_file_id INTEGER REFERENCES files(id),
+    is_dynamic BOOLEAN DEFAULT 0,
+    alias TEXT
+);
+
+CREATE TABLE IF NOT EXISTS calls (
+    id INTEGER PRIMARY KEY,
+    caller_symbol_id INTEGER NOT NULL REFERENCES symbols(id) ON DELETE CASCADE,
+    callee_symbol_id INTEGER REFERENCES symbols(id),
+    callee_name TEXT NOT NULL,
+    line INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS refs (
+    id INTEGER PRIMARY KEY,
+    symbol_id INTEGER NOT NULL REFERENCES symbols(id) ON DELETE CASCADE,
+    file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    line INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS inheritance (
+    id INTEGER PRIMARY KEY,
+    child_symbol_id INTEGER NOT NULL REFERENCES symbols(id) ON DELETE CASCADE,
+    parent_symbol_id INTEGER REFERENCES symbols(id),
+    parent_name TEXT NOT NULL,
+    kind TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_calls_caller ON calls(caller_symbol_id);
+CREATE INDEX IF NOT EXISTS idx_calls_callee ON calls(callee_symbol_id);
+
+CREATE TABLE IF NOT EXISTS routes (
+    id INTEGER PRIMARY KEY,
+    file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    method TEXT NOT NULL,
+    path TEXT NOT NULL,
+    handler_symbol_id INTEGER REFERENCES symbols(id) ON DELETE CASCADE,
+    framework TEXT
+);