codegraphy 0.1.0__py3-none-any.whl

codegraphy-0.1.0.dist-info/METADATA

@@ -0,0 +1,310 @@
+Metadata-Version: 2.4
+Name: codegraphy
+Version: 0.1.0
+Summary: SQLite/PostgreSQL codebase knowledge graph and MCP server for Claude Code
+Author: Charan Kulal
+License-Expression: MIT
+Keywords: mcp,code-analysis,knowledge-graph,claude-code,sqlite,postgresql
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: mcp>=1.0
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary; extra == "postgres"
+Provides-Extra: pgvector
+Requires-Dist: pgvector; extra == "pgvector"
+Provides-Extra: js
+Requires-Dist: tree-sitter; extra == "js"
+Requires-Dist: tree-sitter-javascript; extra == "js"
+Requires-Dist: tree-sitter-typescript; extra == "js"
+Provides-Extra: html
+Requires-Dist: tree-sitter; extra == "html"
+Requires-Dist: tree-sitter-html; extra == "html"
+Provides-Extra: all
+Requires-Dist: psycopg2-binary; extra == "all"
+Requires-Dist: pgvector; extra == "all"
+Requires-Dist: tree-sitter; extra == "all"
+Requires-Dist: tree-sitter-javascript; extra == "all"
+Requires-Dist: tree-sitter-typescript; extra == "all"
+Requires-Dist: tree-sitter-html; extra == "all"
+Dynamic: license-file
+
+# codegraphy
+
+Standalone Python package that parses a codebase into a knowledge graph (PostgreSQL or SQLite) and exposes it as an [MCP](https://modelcontextprotocol.io/) server for Claude Code. Claude calls graph tools instead of `Read` + `Bash(grep)` — cuts exploration token cost by 5–10×.
+
+**Python:** 3.10+  
+**License:** MIT
+
+---
+
+## Why
+
+Claude exploring an unfamiliar codebase today:
+
+| Task | Without codegraphy | With codegraphy |
+|------|-------------------|----------------|
+| Find where `Something` is defined | Read 10 files (~15k tokens) | `search_symbol("Something")` (~200 tokens) |
+| Understand a file's structure | Read full file (~3k tokens) | `get_file_summary("views.py")` (~300 tokens) |
+
+---
+
+## Installation
+
+```bash
+# SQLite-only install (default, zero config):
+pip install codegraphy
+
+# For PostgreSQL support:
+pip install codegraphy[postgres]
+
+# For JS/TS parsing (planned):
+pip install codegraphy[js]
+
+# Everything:
+pip install codegraphy[all]
+```
+
+The base PyPI package keeps SQLite support in the standard library path, so PostgreSQL stays opt-in.
+
+---
+
+## Quickstart
+
+```bash
+# 1. Initialize the database (SQLite by default)
+codegraphy init
+
+# 2. Index your project
+codegraphy index .
+
+# 3. Start the MCP server (stdio, for Claude Code)
+codegraphy serve
+```
+
+That's it. Claude can now query your codebase graph instead of reading files.
+
+---
+
+## CLI Reference
+
+```bash
+codegraphy init [--db URL]         # Create tables (SQLite default, or pass Postgres URL)
+codegraphy index PATH [--exclude]  # Full index of a directory
+codegraphy update                  # Incremental re-index via git diff
+codegraphy serve                   # Start MCP server over stdio
+codegraphy search NAME             # Search symbols (debug, not MCP)
+codegraphy usages QUALIFIED_NAME   # Find usages (debug, not MCP)
+codegraphy stats                   # Show graph statistics
+```
+
+---
+
+## MCP Tools
+
+When running as an MCP server, codegraphy exposes these tools to Claude:
+
+| Tool | Description |
+|------|-------------|
+| `search_symbol(name, kind?, limit?, fallback_grep?)` | Find symbols by name — exact, then substring, then grep fallback |
+| `get_file_summary(file_path)` | Classes, functions, imports in a file without reading it |
+| `find_usages(qualified_name, limit?, fallback_grep?)` | Who imports/calls/references this symbol |
+| `get_context(file_path, line, radius?)` | Read N lines around a line number |
+| `path_between(from_qualified, to_qualified, max_depth?)` | BFS shortest path between two symbols |
+| `grep_search(pattern, include?, exclude?, limit?)` | Direct grep — bypass the graph |
+| `graph_stats()` | File/symbol/edge counts, backend type |
+| `what_touches_model(model_name)` | Django: views, admin, signals referencing a model |
+| `search_semantic(query, limit?)` | pgvector semantic search (Postgres only, planned) |
+
+All tools return a `source` field (`"graph"` or `"grep"`) so Claude can gauge confidence.
+
+---
+
+## Configuration
+
+Priority: CLI flag → environment variable → `codegraphy.toml` → defaults.
+
+### Environment Variables
+
+```bash
+DATABASE_URL=sqlite:///codegraphy.db    # or postgresql://localhost/codegraphy
+REPOLENS_ROOT=.                        # project root for grep fallback
+REPOLENS_PLUGINS=repolens.plugins.django
+```
+
+### Config File (optional)
+
+```toml
+# codegraphy.toml (place at project root)
+database_url = "postgresql://localhost/codegraphy"
+root = "."
+exclude = ["migrations", "node_modules", ".venv", "__pycache__"]
+plugins = ["repolens.plugins.django"]
+```
+
+---
+
+## Claude Code Integration
+
+### Register the MCP server
+
+```json
+// .claude/settings.json
+{
+  "mcpServers": {
+    "codegraphy": {
+      "command": "codegraphy",
+      "args": ["serve"],
+      "env": {
+        "DATABASE_URL": "sqlite:///codegraphy.db"
+      }
+    }
+  }
+}
+```
+
+### Auto-update on session end (optional)
+
+```json
+// .claude/settings.json
+{
+  "hooks": {
+    "Stop": [{
+      "type": "command",
+      "command": "codegraphy update"
+    }]
+  }
+}
+```
+
+---
+
+## Architecture
+
+```
+repolens/
+├── cli.py              # Click CLI entry points
+├── config.py           # DATABASE_URL, REPOLENS_ROOT, plugin list
+├── db/
+│   ├── schema.py       # CREATE TABLE statements (PG + SQLite)
+│   └── store.py        # upsert_symbol, upsert_edge, query helpers
+├── indexer/
+│   ├── base.py         # BaseIndexer ABC, Symbol/Edge dataclasses
+│   ├── python.py       # ast-based Python indexer
+│   └── walker.py       # Filesystem walk + git-diff incremental
+├── mcp/
+│   └── server.py       # FastMCP server + all tool definitions
+├── plugins/
+│   ├── base.py         # BasePlugin ABC
+│   └── django.py       # Django-aware: models, views, signals
+└── session/            # (planned) git-diff hook + memory write
+```
+
+### Database Schema
+
+Three tables power the graph:
+
+- **`cg_files`** — indexed files with git hash for deduplication
+- **`cg_symbols`** — every class, function, method, import with location + summary
+- **`cg_edges`** — relationships: `imports`, `calls`, `inherits`, `references`, `registers`, `handles_signal`
+
+### Indexing Strategy
+
+1. Walk files via `git ls-files` (falls back to `os.walk`)
+2. SHA-256 content hash skips unchanged files
+3. AST parsing extracts symbols and edges
+4. Plugins post-process symbols (e.g., Django re-tags `class` → `model`)
+5. Upsert into database with cascade delete for clean re-indexing
+
+---
+
+## Plugin System
+
+Plugins implement two hooks:
+
+```python
+class BasePlugin:
+    def on_symbol(self, symbol: Symbol) -> Symbol:
+        """Mutate or re-tag a symbol after parsing."""
+        return symbol
+
+    def extra_edges(self, symbols: list[Symbol]) -> list[Edge]:
+        """Derive additional edges from the symbol list."""
+        return []
+```
+
+### Built-in: Django Plugin
+
+Detects Django patterns by file naming convention:
+- Classes in `models.py` → `kind = "model"`
+- Classes/functions in `views.py` → `kind = "view"`
+
+Enable via environment variable:
+```bash
+REPOLENS_PLUGINS=repolens.plugins.django
+```
+
+---
+
+## Current Status
+
+| Milestone | Status |
+|-----------|--------|
+| M1 — Schema + Python indexer + `codegraphy index` | ✅ Complete |
+| M2 — `search_symbol` + `get_file_summary` + MCP serve | ✅ Complete |
+| M3 — `find_usages` + `path_between` + `get_context` + grep fallback | ✅ Complete |
+| M4 — `codegraphy update` (incremental) | ✅ Complete |
+| M5 — Django plugin | 🔶 Partial (symbol re-tagging, no admin/signal edges) |
+| M6 — Semantic search (pgvector) | ⬜ Stub only |
+| M7 — JS/TS indexer (tree-sitter) | ⬜ Planned |
+| M8 — HTML/Template indexer | ⬜ Planned |
+| M9 — `grep_search` tool + cross-language edges | 🔶 grep_search done, cross-lang edges planned |
+
+---
+
+## Development
+
+```bash
+# Clone and install in editable mode
+git clone <repo-url> && cd codegraphy
+python -m venv .venv && source .venv/bin/activate
+pip install -e .
+
+# Initialize local DB and index this project
+codegraphy init
+codegraphy index .
+
+# Check stats
+codegraphy stats
+```
+
+## Publishing
+
+`codegraphy` is configured to build as a standard PyPI distribution from `pyproject.toml`.
+
+For PyPI trusted publishing, use **`publish.yml`** as the workflow name. The workflow file lives at `.github/workflows/publish.yml`.
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+---
+
+## What It Is NOT
+
+- Not a code execution sandbox
+- Not a test runner or linter
+- Not a replacement for LSP/IDE features
+- Not AI-generated summaries by default (uses docstrings; AI summaries are opt-in future)

codegraphy-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+codegraphy-0.1.0.dist-info/licenses/LICENSE,sha256=Rp72yjCco7pl_tUJuWcoVaQJbavF_o1EduIzGlWgMBs,1069
+repolens/__init__.py,sha256=oiUP7r1EzCXbTJlVA0uaqMFzlgb485PpzsgPSxc3tHU,133
+repolens/cli.py,sha256=YHklhHZL3c48jBRVGCMiILOLXHNz-tqA9LPF-d_hR3Y,4764
+repolens/config.py,sha256=FsBleokRpJLo6uY9Hxep8ba9Wona9SBwERbtQOfPN7Y,445
+repolens/db/__init__.py,sha256=N0we97ndqage4suzlmrky148cqc077smh9yRW7fRmtk,46
+repolens/db/schema.py,sha256=b0LXLgDe7pAIilraeHf8RwlSHCvXAm_zJyfWLDGLuB8,3073
+repolens/db/store.py,sha256=K60Q4GaFDMD2UrME8h5UCEbSz7JyNTtjhohPTF7K034,6911
+repolens/indexer/__init__.py,sha256=323iYhXcMZCFSi9BbD9eFIrvKn31hgxvx8oLt5fOawQ,185
+repolens/indexer/base.py,sha256=Jhe_1EROe1qn2BKwiWI90HFT76fQC3fqKsuZoTXWoqc,648
+repolens/indexer/python.py,sha256=0IbfCAxQYPpArNocdEOZRVq_PVwvGKznV6efTI0uPvU,6764
+repolens/indexer/walker.py,sha256=Uexo2C6WUIh9F5N3hZK1f9LHIqRgAn_D4BDEM0j3AG4,2397
+repolens/mcp/__init__.py,sha256=uJZf2o3FWA4zVaWMAOdQNMl2JF23TD2dfCrD9Rw2Syg,61
+repolens/mcp/server.py,sha256=fdDRMSlKjlHKylijHMu5rL4YOg0sK2bCF-G3920WyGw,10534
+repolens/plugins/__init__.py,sha256=ex5qITE4l8sI_bPiywyXw_THj1MylMagOgXK0_0w9Sw,55
+repolens/plugins/base.py,sha256=rGZ3XRxTFSZBZ_Wad-b2EFtIjotA-TOHHAAaabvIYTY,374
+repolens/plugins/django.py,sha256=6ZNacSklsL5S4oWPzlaM1bA295Wpo-Vry9tUUddab0g,996
+codegraphy-0.1.0.dist-info/METADATA,sha256=0o_E0X9rU0pxr7AGlVh4nmMUkYDl_uuWScvDQAE0OTM,9266
+codegraphy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codegraphy-0.1.0.dist-info/entry_points.txt,sha256=3lQGELX3dsARcq4DzrX1wskfIj86KCp7bXL8Qv-D8EA,48
+codegraphy-0.1.0.dist-info/top_level.txt,sha256=7EK5ft9AlN9kOeOjzFv_PgnLxREn2EGvgu5jZdcL9CA,9
+codegraphy-0.1.0.dist-info/RECORD,,

codegraphy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codegraphy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codegraphy = repolens.cli:cli

codegraphy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Charan Kulal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

codegraphy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+repolens

repolens/__init__.py

@@ -0,0 +1,5 @@
+"""
+codegraphy: Parses a codebase into a Postgres/SQLite knowledge graph and exposes it as an MCP server.
+"""
+
+__version__ = "0.1.0"

repolens/cli.py

@@ -0,0 +1,141 @@
+import click
+from .config import load_config
+
+@click.group()
+def cli():
+    """codegraphy: Codebase knowledge graph & MCP server."""
+    load_config()
+
+@cli.command()
+@click.option('--db', help='Database URL (e.g. postgresql://localhost/codegraphy)')
+def init(db):
+    """Initialize the database schema."""
+    import repolens.config as config
+    from repolens.db.store import Store
+    
+    db_url = db or config.DATABASE_URL
+    click.echo(f"Initializing schema for {db_url}...")
+    store = Store(db_url)
+    store.init_schema()
+    click.echo("Schema initialized.")
+
+@cli.command()
+@click.argument('path', default='.')
+@click.option('--exclude', help='Comma-separated list of directories to exclude')
+def index(path, exclude):
+    """Index a directory into the graph."""
+    import repolens.config as config
+    from repolens.db.store import Store
+    from repolens.indexer.walker import index_path
+    
+    click.echo(f"Indexing {path}...")
+    store = Store(config.DATABASE_URL)
+    exclude_list = exclude.split(',') if exclude else None
+    
+    # Load plugins
+    plugins = [] # TODO: instantiate from config.REPOLENS_PLUGINS
+    
+    count = index_path(path, store, plugins, exclude_list)
+    click.echo(f"Indexed {count} files.")
+
+@cli.command()
+def update():
+    """Update index incrementally based on git diff."""
+    import subprocess
+    import repolens.config as config
+    from repolens.db.store import Store
+    from repolens.indexer.walker import index_path
+    
+    click.echo("Updating index...")
+    try:
+        res = subprocess.run(['git', 'diff', '--name-only', 'HEAD'], capture_output=True, text=True)
+        changed_files = res.stdout.splitlines()
+    except Exception:
+        click.echo("Not a git repository or no HEAD.")
+        return
+        
+    store = Store(config.DATABASE_URL)
+    plugins = [] # TODO
+    
+    count = 0
+    for file_path in changed_files:
+        # Instead of calling index_path, we should just index the specific files
+        # Re-using index_path is tricky since it takes a root.
+        # We can just write a small loop here for the changed files.
+        import os
+        from repolens.indexer.walker import INDEXERS, sha256
+        
+        path = os.path.abspath(file_path)
+        if not os.path.exists(path):
+            continue
+            
+        indexer = next((i for i in INDEXERS if i.can_handle(path)), None)
+        if not indexer:
+            continue
+            
+        try:
+            with open(path, 'rb') as f:
+                content_bytes = f.read()
+            file_hash = sha256(content_bytes)
+            if store.get_file_hash(path) == file_hash:
+                continue
+            
+            content_str = content_bytes.decode('utf-8', errors='replace')
+            symbols, edges = indexer.index_file(path, content_str)
+            
+            for plugin in plugins:
+                symbols = [plugin.on_symbol(s) for s in symbols]
+                edges.extend(plugin.extra_edges(symbols))
+                
+            store.upsert_file(path, file_hash, symbols, edges)
+            count += 1
+        except Exception:
+            pass
+            
+    click.echo(f"Updated {count} files.")
+
+@cli.command()
+def serve():
+    """Start the MCP server over stdio."""
+    from repolens.mcp.server import start_server
+    click.echo("Starting MCP server...", err=True)
+    start_server()
+
+@cli.command()
+@click.argument('name')
+def search(name):
+    """Search for a symbol in the graph."""
+    from repolens.mcp.server import search_symbol
+    results = search_symbol(name)
+    for res in results:
+        click.echo(f"[{res['source']}] {res.get('qualified_name') or res.get('file_path')} - {res.get('kind', 'grep')} @ {res['line_start']}")
+
+@cli.command()
+@click.argument('name')
+def usages(name):
+    """Find usages of a symbol."""
+    from repolens.mcp.server import find_usages
+    results = find_usages(name)
+    for res in results:
+        click.echo(f"[{res['source']}] {res.get('from_qualified') or res.get('file_path')} - {res.get('relation', 'grep')} @ {res['line_start']}")
+
+@cli.command()
+def stats():
+    """Show graph statistics."""
+    from repolens.db.store import Store
+    import repolens.config as config
+    store = Store(config.DATABASE_URL)
+    with store.get_connection() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT COUNT(*) FROM cg_files")
+        files = cursor.fetchone()[0]
+        cursor.execute("SELECT COUNT(*) FROM cg_symbols")
+        symbols = cursor.fetchone()[0]
+        cursor.execute("SELECT COUNT(*) FROM cg_edges")
+        edges = cursor.fetchone()[0]
+        click.echo(f"Files: {files}")
+        click.echo(f"Symbols: {symbols}")
+        click.echo(f"Edges: {edges}")
+
+if __name__ == '__main__':
+    cli()

repolens/config.py

@@ -0,0 +1,13 @@
+import os
+
+# Default configuration
+DATABASE_URL = os.environ.get("DATABASE_URL", "sqlite:///codegraphy.db")
+REPOLENS_ROOT = os.environ.get("REPOLENS_ROOT", ".")
+
+# Plugin list can be derived from env vars or TOML
+_plugins_env = os.environ.get("REPOLENS_PLUGINS", "")
+REPOLENS_PLUGINS = [p.strip() for p in _plugins_env.split(",")] if _plugins_env else []
+
+def load_config():
+    # Placeholder for loading from codegraphy.toml if needed
+    pass

repolens/db/__init__.py

@@ -0,0 +1,3 @@
+from .store import Store
+
+__all__ = ["Store"]

repolens/db/schema.py

@@ -0,0 +1,84 @@
+PG_SCHEMA = """
+CREATE TABLE IF NOT EXISTS cg_files (
+    id          SERIAL PRIMARY KEY,
+    file_path   TEXT UNIQUE NOT NULL,
+    module_path TEXT,
+    summary     TEXT,
+    symbol_count INTEGER DEFAULT 0,
+    git_hash    TEXT,
+    last_indexed TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS cg_symbols (
+    id              SERIAL PRIMARY KEY,
+    name            TEXT NOT NULL,
+    qualified_name  TEXT UNIQUE NOT NULL,
+    kind            TEXT NOT NULL,
+    file_path       TEXT NOT NULL REFERENCES cg_files(file_path) ON DELETE CASCADE,
+    line_start      INTEGER,
+    line_end        INTEGER,
+    summary         TEXT,
+    raw_signature   TEXT,
+    extra           JSONB,
+    last_indexed    TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS cg_edges (
+    from_id  INTEGER NOT NULL REFERENCES cg_symbols(id) ON DELETE CASCADE,
+    to_id    INTEGER NOT NULL REFERENCES cg_symbols(id) ON DELETE CASCADE,
+    relation TEXT NOT NULL,
+    PRIMARY KEY (from_id, to_id, relation)
+);
+
+CREATE INDEX IF NOT EXISTS idx_symbols_name       ON cg_symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbols_file       ON cg_symbols(file_path);
+CREATE INDEX IF NOT EXISTS idx_symbols_kind       ON cg_symbols(kind);
+CREATE INDEX IF NOT EXISTS idx_symbols_qualname   ON cg_symbols(qualified_name);
+CREATE INDEX IF NOT EXISTS idx_edges_from         ON cg_edges(from_id);
+CREATE INDEX IF NOT EXISTS idx_edges_to           ON cg_edges(to_id);
+"""
+
+SQLITE_SCHEMA = """
+CREATE TABLE IF NOT EXISTS cg_files (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_path   TEXT UNIQUE NOT NULL,
+    module_path TEXT,
+    summary     TEXT,
+    symbol_count INTEGER DEFAULT 0,
+    git_hash    TEXT,
+    last_indexed DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS cg_symbols (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    name            TEXT NOT NULL,
+    qualified_name  TEXT UNIQUE NOT NULL,
+    kind            TEXT NOT NULL,
+    file_path       TEXT NOT NULL REFERENCES cg_files(file_path) ON DELETE CASCADE,
+    line_start      INTEGER,
+    line_end        INTEGER,
+    summary         TEXT,
+    raw_signature   TEXT,
+    extra           TEXT,
+    last_indexed    DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS cg_edges (
+    from_id  INTEGER NOT NULL REFERENCES cg_symbols(id) ON DELETE CASCADE,
+    to_id    INTEGER NOT NULL REFERENCES cg_symbols(id) ON DELETE CASCADE,
+    relation TEXT NOT NULL,
+    PRIMARY KEY (from_id, to_id, relation)
+);
+
+CREATE INDEX IF NOT EXISTS idx_symbols_name       ON cg_symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbols_file       ON cg_symbols(file_path);
+CREATE INDEX IF NOT EXISTS idx_symbols_kind       ON cg_symbols(kind);
+CREATE INDEX IF NOT EXISTS idx_symbols_qualname   ON cg_symbols(qualified_name);
+CREATE INDEX IF NOT EXISTS idx_edges_from         ON cg_edges(from_id);
+CREATE INDEX IF NOT EXISTS idx_edges_to           ON cg_edges(to_id);
+"""
+
+def get_schema(db_url: str) -> str:
+    if db_url.startswith("postgres"):
+        return PG_SCHEMA
+    return SQLITE_SCHEMA