codegraphy 0.1.1__tar.gz → 2.0.0__tar.gz

{codegraphy-0.1.1 → codegraphy-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphy
-Version: 0.1.1
+Version: 2.0.0
 Summary: SQLite/PostgreSQL codebase knowledge graph and MCP server for Claude Code
 Author: Charan Kulal
 License-Expression: MIT
@@ -80,6 +80,37 @@ The base PyPI package keeps SQLite support in the standard library path, so Post
 
 ---
 
+## PostgreSQL
+
+Install PostgreSQL support:
+
+```bash
+pip install 'codegraphy[postgres]'
+```
+
+Initialize with a PostgreSQL URL:
+
+```bash
+codegraphy init --db postgresql://USER:PASSWORD@HOST:PORT/DBNAME
+```
+
+Example:
+
+```bash
+codegraphy init --db postgresql://postgres:postgres@localhost:5432/codegraphy
+```
+
+Or set `DATABASE_URL` once and reuse it:
+
+```bash
+export DATABASE_URL=postgresql://postgres:postgres@localhost:5432/codegraphy
+codegraphy init
+codegraphy index .
+codegraphy serve
+```
+
+---
+
 ## Quickstart
 
 ```bash
@@ -109,6 +140,8 @@ codegraphy usages QUALIFIED_NAME   # Find usages (debug, not MCP)
 codegraphy stats                   # Show graph statistics
 ```
 
+`codegraphy index` and `codegraphy update` show progress while they run, then print a summary with files scanned, files indexed, and elapsed time. `codegraphy serve` also shows startup progress and then reports when the MCP server is ready and waiting for a stdio client.
+
 ---
 
 ## MCP Tools

{codegraphy-0.1.1 → codegraphy-2.0.0}/README.md

@@ -40,6 +40,37 @@ The base PyPI package keeps SQLite support in the standard library path, so Post
 
 ---
 
+## PostgreSQL
+
+Install PostgreSQL support:
+
+```bash
+pip install 'codegraphy[postgres]'
+```
+
+Initialize with a PostgreSQL URL:
+
+```bash
+codegraphy init --db postgresql://USER:PASSWORD@HOST:PORT/DBNAME
+```
+
+Example:
+
+```bash
+codegraphy init --db postgresql://postgres:postgres@localhost:5432/codegraphy
+```
+
+Or set `DATABASE_URL` once and reuse it:
+
+```bash
+export DATABASE_URL=postgresql://postgres:postgres@localhost:5432/codegraphy
+codegraphy init
+codegraphy index .
+codegraphy serve
+```
+
+---
+
 ## Quickstart
 
 ```bash
@@ -69,6 +100,8 @@ codegraphy usages QUALIFIED_NAME   # Find usages (debug, not MCP)
 codegraphy stats                   # Show graph statistics
 ```
 
+`codegraphy index` and `codegraphy update` show progress while they run, then print a summary with files scanned, files indexed, and elapsed time. `codegraphy serve` also shows startup progress and then reports when the MCP server is ready and waiting for a stdio client.
+
 ---
 
 ## MCP Tools

{codegraphy-0.1.1 → codegraphy-2.0.0}/codegraphy/__init__.py

@@ -2,4 +2,4 @@
 codegraphy: Parses a codebase into a Postgres/SQLite knowledge graph and exposes it as an MCP server.
 """
 
-__version__ = "0.1.1"
+__version__ = "2.0.0"

{codegraphy-0.1.1 → codegraphy-2.0.0}/codegraphy/cli.py

@@ -1,5 +1,31 @@
 import click
 from .config import load_config
+import time
+
+def _format_elapsed(seconds: float) -> str:
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes, remaining = divmod(seconds, 60)
+    return f"{int(minutes)}m {remaining:.1f}s"
+
+def _run_with_progress(label: str, files: list[str], runner):
+    total_files = len(files)
+    start = time.monotonic()
+
+    if total_files == 0:
+        click.echo(f"{label}...")
+        click.echo("Scanned 0 files, indexed 0 files in 0.0s.")
+        return 0
+
+    with click.progressbar(length=total_files, label=label, show_eta=True, show_percent=True) as bar:
+        def progress_callback(path, scanned_count, indexed_count, total_count):
+            bar.update(scanned_count - bar.pos)
+
+        indexed_count = runner(progress_callback)
+
+    elapsed = _format_elapsed(time.monotonic() - start)
+    click.echo(f"Scanned {total_files} files, indexed {indexed_count} files in {elapsed}.")
+    return indexed_count
 
 @click.group()
 def cli():
@@ -26,26 +52,30 @@ def index(path, exclude):
     """Index a directory into the graph."""
     import codegraphy.config as config
     from codegraphy.db.store import Store
-    from codegraphy.indexer.walker import index_path
-    
-    click.echo(f"Indexing {path}...")
+    from codegraphy.indexer.walker import DEFAULT_EXCLUDE, get_files_to_index, index_files
+
     store = Store(config.DATABASE_URL)
-    exclude_list = exclude.split(',') if exclude else None
-    
+    exclude_list = exclude.split(',') if exclude else DEFAULT_EXCLUDE
+    files = get_files_to_index(path, exclude_list)
+
     # Load plugins
     plugins = [] # TODO: instantiate from config.CODEGRAPHY_PLUGINS
-    
-    count = index_path(path, store, plugins, exclude_list)
-    click.echo(f"Indexed {count} files.")
+
+    _run_with_progress(
+        f"Indexing {path}",
+        files,
+        lambda progress_callback: index_files(files, store, plugins, progress_callback=progress_callback),
+    )
 
 @cli.command()
 def update():
     """Update index incrementally based on git diff."""
     import subprocess
+    import os
     import codegraphy.config as config
     from codegraphy.db.store import Store
+    from codegraphy.indexer.walker import index_files
     
-    click.echo("Updating index...")
     try:
         res = subprocess.run(['git', 'diff', '--name-only', 'HEAD'], capture_output=True, text=True)
         changed_files = res.stdout.splitlines()
@@ -55,49 +85,49 @@ def update():
         
     store = Store(config.DATABASE_URL)
     plugins = [] # TODO
-    
-    count = 0
+
+    paths = []
     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 codegraphy.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.")
+        path = os.path.join('.', file_path)
+        if os.path.exists(path):
+            paths.append(path)
+
+    _run_with_progress(
+        "Updating index",
+        paths,
+        lambda progress_callback: index_files(paths, store, plugins, progress_callback=progress_callback),
+    )
 
 @cli.command()
 def serve():
     """Start the MCP server over stdio."""
-    from codegraphy.mcp.server import start_server
-    click.echo("Starting MCP server...", err=True)
+    from codegraphy.mcp.server import prepare_server, start_server
+
+    startup_steps = [
+        "Loading MCP tool registry",
+        "Connecting to graph database",
+        "Starting stdio transport",
+    ]
+    server_info = None
+
+    with click.progressbar(
+        length=len(startup_steps),
+        label="Starting MCP server",
+        show_eta=False,
+        show_percent=True,
+        file=click.get_text_stream('stderr'),
+    ) as bar:
+        bar.update(1)
+        server_info = prepare_server()
+        bar.update(1)
+        bar.update(1)
+
+    click.echo(
+        f"MCP server ready on stdio "
+        f"(backend: {server_info['backend']}, files: {server_info['files']}, symbols: {server_info['symbols']}). "
+        f"Waiting for client...",
+        err=True,
+    )
     start_server()
 
 @cli.command()

codegraphy-2.0.0/codegraphy/db/store.py

@@ -0,0 +1,204 @@
+import json
+import sqlite3
+from urllib.parse import urlparse
+from contextlib import contextmanager
+
+from .schema import get_schema
+
+try:
+    import psycopg2
+    from psycopg2.extras import Json
+except ImportError:
+    psycopg2 = None
+
+class Store:
+    def __init__(self, db_url: str):
+        self.db_url = db_url
+        self.is_postgres = db_url.startswith("postgres")
+        
+        if self.is_postgres and psycopg2 is None:
+            raise ImportError("psycopg2-binary is required for postgres support")
+            
+        if self.is_postgres:
+            parsed = urlparse(db_url)
+            self.conn_kwargs = {
+                'dbname': parsed.path[1:],
+                'user': parsed.username,
+                'password': parsed.password,
+                'host': parsed.hostname,
+                'port': parsed.port,
+            }
+            # Remove None values
+            self.conn_kwargs = {k: v for k, v in self.conn_kwargs.items() if v is not None}
+        else:
+            # Handle sqlite:///path
+            self.db_path = db_url.replace("sqlite:///", "")
+            if not self.db_path:
+                self.db_path = "codegraphy.db"
+
+    @contextmanager
+    def get_connection(self):
+        if self.is_postgres:
+            conn = psycopg2.connect(**self.conn_kwargs)
+        else:
+            conn = sqlite3.connect(self.db_path)
+            conn.execute("PRAGMA foreign_keys = ON")
+            
+        try:
+            yield conn
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+        finally:
+            conn.close()
+
+    def init_schema(self):
+        schema_sql = get_schema(self.db_url)
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            if self.is_postgres:
+                cursor.execute(schema_sql)
+            else:
+                # sqlite3 executescript for multiple statements
+                cursor.executescript(schema_sql)
+
+    def _placeholder(self) -> str:
+        return "%s" if self.is_postgres else "?"
+
+    def _cursor(self, conn):
+        return conn.cursor()
+
+    def get_file_hash(self, file_path: str, conn=None) -> str:
+        if conn is None:
+            with self.get_connection() as managed_conn:
+                return self.get_file_hash(file_path, managed_conn)
+
+        cursor = self._cursor(conn)
+        cursor.execute(
+            f"SELECT git_hash FROM cg_files WHERE file_path = {self._placeholder()}",
+            (file_path,),
+        )
+        row = cursor.fetchone()
+        return row[0] if row else None
+
+    def get_file_hashes(self, file_paths: list[str], conn=None) -> dict[str, str]:
+        if not file_paths:
+            return {}
+
+        if conn is None:
+            with self.get_connection() as managed_conn:
+                return self.get_file_hashes(file_paths, managed_conn)
+
+        cursor = self._cursor(conn)
+        placeholder = self._placeholder()
+        file_hashes = {}
+
+        batch_size = 500
+        for i in range(0, len(file_paths), batch_size):
+            batch = file_paths[i:i + batch_size]
+            placeholders = ",".join([placeholder] * len(batch))
+            cursor.execute(
+                f"SELECT file_path, git_hash FROM cg_files WHERE file_path IN ({placeholders})",
+                tuple(batch),
+            )
+            for file_path, git_hash in cursor.fetchall():
+                file_hashes[file_path] = git_hash
+
+        return file_hashes
+
+    def _dedupe_symbols(self, symbols: list) -> list:
+        deduped = []
+        seen = set()
+        for symbol in symbols:
+            if symbol.qualified_name in seen:
+                continue
+            seen.add(symbol.qualified_name)
+            deduped.append(symbol)
+        return deduped
+
+    def _upsert_file_with_cursor(self, cursor, file_path: str, git_hash: str, symbols: list, edges: list):
+        placeholder = self._placeholder()
+
+        # Upsert file
+        if self.is_postgres:
+            cursor.execute(f"""
+                INSERT INTO cg_files (file_path, git_hash, symbol_count, last_indexed)
+                VALUES ({placeholder}, {placeholder}, {placeholder}, NOW())
+                ON CONFLICT (file_path) DO UPDATE
+                SET git_hash = EXCLUDED.git_hash, symbol_count = EXCLUDED.symbol_count, last_indexed = NOW()
+            """, (file_path, git_hash, len(symbols)))
+        else:
+            cursor.execute(f"""
+                INSERT INTO cg_files (file_path, git_hash, symbol_count, last_indexed)
+                VALUES ({placeholder}, {placeholder}, {placeholder}, CURRENT_TIMESTAMP)
+                ON CONFLICT(file_path) DO UPDATE
+                SET git_hash=excluded.git_hash, symbol_count=excluded.symbol_count, last_indexed=CURRENT_TIMESTAMP
+            """, (file_path, git_hash, len(symbols)))
+
+        # Delete old symbols (cascade deletes edges)
+        cursor.execute(f"DELETE FROM cg_symbols WHERE file_path = {placeholder}", (file_path,))
+
+        # Insert new symbols
+        if symbols:
+            symbol_records = []
+            for s in symbols:
+                extra_val = Json(s.extra) if self.is_postgres else json.dumps(s.extra)
+                symbol_records.append((
+                    s.name, s.qualified_name, s.kind, s.file_path,
+                    s.line_start, s.line_end, s.summary, s.raw_signature, extra_val
+                ))
+
+            cursor.executemany(f"""
+                INSERT INTO cg_symbols (name, qualified_name, kind, file_path, line_start, line_end, summary, raw_signature, extra)
+                VALUES ({placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder})
+            """, symbol_records)
+
+        if edges:
+            quals = set()
+            for e in edges:
+                quals.add(e.from_qualified)
+                quals.add(e.to_qualified)
+
+            if quals:
+                quals_list = list(quals)
+                qual_to_id = {}
+
+                batch_size = 500
+                for i in range(0, len(quals_list), batch_size):
+                    batch = quals_list[i:i + batch_size]
+                    placeholders = ",".join([placeholder] * len(batch))
+                    cursor.execute(
+                        f"SELECT id, qualified_name FROM cg_symbols WHERE qualified_name IN ({placeholders})",
+                        tuple(batch),
+                    )
+                    for row in cursor.fetchall():
+                        qual_to_id[row[1]] = row[0]
+
+                edge_records = []
+                for e in edges:
+                    from_id = qual_to_id.get(e.from_qualified)
+                    to_id = qual_to_id.get(e.to_qualified)
+                    if from_id and to_id:
+                        edge_records.append((from_id, to_id, e.relation))
+
+                if edge_records:
+                    cursor.executemany(f"""
+                        INSERT INTO cg_edges (from_id, to_id, relation)
+                        VALUES ({placeholder}, {placeholder}, {placeholder})
+                        ON CONFLICT DO NOTHING
+                    """, edge_records)
+
+    def upsert_file(self, file_path: str, git_hash: str, symbols: list, edges: list, conn=None):
+        """
+        Replace symbols and edges for a file.
+        """
+        symbols = self._dedupe_symbols(symbols)
+        if conn is None:
+            with self.get_connection() as managed_conn:
+                cursor = self._cursor(managed_conn)
+                self._upsert_file_with_cursor(cursor, file_path, git_hash, symbols, edges)
+            return
+
+        cursor = self._cursor(conn)
+        self._upsert_file_with_cursor(cursor, file_path, git_hash, symbols, edges)

{codegraphy-0.1.1 → codegraphy-2.0.0}/codegraphy/indexer/python.py

@@ -44,6 +44,14 @@ class PythonIndexer(BaseIndexer):
                     return f"{module_path}.{name}" if module_path else name
                 return f"{module_path}.{'.'.join(self.current_scope)}.{name}"
 
+            def get_import_qualname(self, node, imported_name, source_module):
+                scope = ".".join(self.current_scope)
+                parts = [module_path] if module_path else []
+                if scope:
+                    parts.append(scope)
+                parts.extend(["__import__", str(node.lineno), str(node.col_offset), source_module, imported_name])
+                return ".".join(parts)
+
             def visit_ClassDef(self, node):
                 qualname = self.get_qualname(node.name)
                 summary = ast.get_docstring(node) or ""
@@ -108,7 +116,7 @@ class PythonIndexer(BaseIndexer):
                 for alias in node.names:
                     # module level import
                     # e.g., import os
-                    qualname = self.get_qualname(alias.asname or alias.name)
+                    qualname = self.get_import_qualname(node, alias.asname or alias.name, alias.name)
                     symbols.append(Symbol(
                         name=alias.asname or alias.name,
                         qualified_name=qualname,
@@ -129,7 +137,7 @@ class PythonIndexer(BaseIndexer):
                 if node.module:
                     for alias in node.names:
                         name = alias.asname or alias.name
-                        qualname = self.get_qualname(name)
+                        qualname = self.get_import_qualname(node, name, node.module)
                         symbols.append(Symbol(
                             name=name,
                             qualified_name=qualname,

codegraphy-2.0.0/codegraphy/indexer/walker.py

@@ -0,0 +1,104 @@
+import os
+import hashlib
+import subprocess
+from .python import PythonIndexer
+from ..db.store import Store
+
+INDEXERS = [PythonIndexer()]
+DEFAULT_EXCLUDE = [
+    '.git',
+    'node_modules',
+    '__pycache__',
+    '.venv',
+    'dist',
+    'build',
+    '.tox',
+    '.pytest_cache',
+    'migrations',
+]
+
+def sha256(content: bytes) -> str:
+    return hashlib.sha256(content).hexdigest()
+
+def get_files_to_index(root: str, exclude: list[str]) -> list[str]:
+    # Use git ls-files if possible
+    try:
+        result = subprocess.run(
+            ['git', 'ls-files'],
+            cwd=root,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        files = result.stdout.splitlines()
+        # Make paths absolute
+        files = [os.path.join(root, f) for f in files]
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Fallback to os.walk
+        files = []
+        for dirpath, dirnames, filenames in os.walk(root):
+            # rudimentary exclude
+            dirnames[:] = [d for d in dirnames if d not in exclude and not d.startswith('.')]
+            for f in filenames:
+                files.append(os.path.join(dirpath, f))
+    
+    # Filter excludes
+    if exclude:
+        filtered = []
+        for f in files:
+            if not any(ex in f for ex in exclude):
+                filtered.append(f)
+        files = filtered
+        
+    return files
+
+def index_files(files: list[str], store: Store, plugins: list, progress_callback=None):
+    indexed_count = 0
+    if not files:
+        return indexed_count
+
+    with store.get_connection() as conn:
+        existing_hashes = store.get_file_hashes(files, conn=conn)
+
+        total_files = len(files)
+        for scanned_count, path in enumerate(files, start=1):
+            indexer = next((i for i in INDEXERS if i.can_handle(path)), None)
+            if not indexer:
+                if progress_callback:
+                    progress_callback(path, scanned_count, indexed_count, total_files)
+                continue
+
+            try:
+                with open(path, 'rb') as f:
+                    content_bytes = f.read()
+            except OSError:
+                if progress_callback:
+                    progress_callback(path, scanned_count, indexed_count, total_files)
+                continue
+
+            file_hash = sha256(content_bytes)
+            if existing_hashes.get(path) == file_hash:
+                if progress_callback:
+                    progress_callback(path, scanned_count, indexed_count, total_files)
+                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, conn=conn)
+            existing_hashes[path] = file_hash
+            indexed_count += 1
+
+            if progress_callback:
+                progress_callback(path, scanned_count, indexed_count, total_files)
+
+    return indexed_count
+
+def index_path(root: str, store: Store, plugins: list, exclude: list[str] = None, progress_callback=None):
+    exclude = exclude or DEFAULT_EXCLUDE
+    files = get_files_to_index(root, exclude)
+    return index_files(files, store, plugins, progress_callback=progress_callback)

{codegraphy-0.1.1 → codegraphy-2.0.0}/codegraphy/mcp/server.py

@@ -4,13 +4,40 @@ from ..config import DATABASE_URL, CODEGRAPHY_ROOT
 import subprocess
 
 mcp = FastMCP("codegraphy")
-store = Store(DATABASE_URL)
+_store = None
+
+def get_store() -> Store:
+    global _store
+    if _store is None:
+        _store = Store(DATABASE_URL)
+    return _store
+
+def _graph_stats(store: Store) -> dict:
+    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]
+        return {
+            "files": files,
+            "symbols": symbols,
+            "edges": edges,
+            "backend": "postgres" if store.is_postgres else "sqlite"
+        }
+
+def prepare_server() -> dict:
+    store = get_store()
+    return _graph_stats(store)
 
 @mcp.tool()
 def search_symbol(name: str, kind: str = None, limit: int = 10, fallback_grep: bool = True) -> list[dict]:
     """
     Find symbols by name (exact, prefix, or substring match).
     """
+    store = get_store()
     results = []
     
     with store.get_connection() as conn:
@@ -75,6 +102,7 @@ def get_file_summary(file_path: str) -> dict:
     """
     One-shot summary of a file: classes, functions, imports.
     """
+    store = get_store()
     with store.get_connection() as conn:
         cursor = conn.cursor()
         p = "%s" if store.is_postgres else "?"
@@ -114,6 +142,7 @@ def find_usages(qualified_name: str, limit: int = 20, fallback_grep: bool = True
     """
     Find every symbol that imports, calls, or references this symbol.
     """
+    store = get_store()
     results = []
     with store.get_connection() as conn:
         cursor = conn.cursor()
@@ -187,6 +216,7 @@ def path_between(from_qualified: str, to_qualified: str, max_depth: int = 6) ->
     """
     BFS shortest path through the edge graph between two symbols.
     """
+    store = get_store()
     with store.get_connection() as conn:
         cursor = conn.cursor()
         p = "%s" if store.is_postgres else "?"
@@ -239,6 +269,7 @@ def search_semantic(query: str, limit: int = 10) -> list[dict]:
     pgvector semantic search over symbol summaries.
     No-ops on SQLite.
     """
+    store = get_store()
     if not store.is_postgres:
         return []
         
@@ -248,20 +279,7 @@ def search_semantic(query: str, limit: int = 10) -> list[dict]:
 @mcp.tool()
 def graph_stats() -> dict:
     """Quick health check."""
-    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]
-        return {
-            "files": files,
-            "symbols": symbols,
-            "edges": edges,
-            "backend": "postgres" if store.is_postgres else "sqlite"
-        }
+    return _graph_stats(get_store())
 
 @mcp.tool()
 def grep_search(pattern: str, include: list[str] = None, exclude: list[str] = None, limit: int = 30) -> list[dict]:

{codegraphy-0.1.1 → codegraphy-2.0.0}/codegraphy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphy
-Version: 0.1.1
+Version: 2.0.0
 Summary: SQLite/PostgreSQL codebase knowledge graph and MCP server for Claude Code
 Author: Charan Kulal
 License-Expression: MIT
@@ -80,6 +80,37 @@ The base PyPI package keeps SQLite support in the standard library path, so Post
 
 ---
 
+## PostgreSQL
+
+Install PostgreSQL support:
+
+```bash
+pip install 'codegraphy[postgres]'
+```
+
+Initialize with a PostgreSQL URL:
+
+```bash
+codegraphy init --db postgresql://USER:PASSWORD@HOST:PORT/DBNAME
+```
+
+Example:
+
+```bash
+codegraphy init --db postgresql://postgres:postgres@localhost:5432/codegraphy
+```
+
+Or set `DATABASE_URL` once and reuse it:
+
+```bash
+export DATABASE_URL=postgresql://postgres:postgres@localhost:5432/codegraphy
+codegraphy init
+codegraphy index .
+codegraphy serve
+```
+
+---
+
 ## Quickstart
 
 ```bash
@@ -109,6 +140,8 @@ codegraphy usages QUALIFIED_NAME   # Find usages (debug, not MCP)
 codegraphy stats                   # Show graph statistics
 ```
 
+`codegraphy index` and `codegraphy update` show progress while they run, then print a summary with files scanned, files indexed, and elapsed time. `codegraphy serve` also shows startup progress and then reports when the MCP server is ready and waiting for a stdio client.
+
 ---
 
 ## MCP Tools

codegraphy-0.1.1/codegraphy/db/store.py

@@ -1,162 +0,0 @@
-import json
-import sqlite3
-from urllib.parse import urlparse
-from contextlib import contextmanager
-
-from .schema import get_schema
-
-try:
-    import psycopg2
-    from psycopg2.extras import Json
-except ImportError:
-    psycopg2 = None
-
-class Store:
-    def __init__(self, db_url: str):
-        self.db_url = db_url
-        self.is_postgres = db_url.startswith("postgres")
-        
-        if self.is_postgres and psycopg2 is None:
-            raise ImportError("psycopg2-binary is required for postgres support")
-            
-        if self.is_postgres:
-            parsed = urlparse(db_url)
-            self.conn_kwargs = {
-                'dbname': parsed.path[1:],
-                'user': parsed.username,
-                'password': parsed.password,
-                'host': parsed.hostname,
-                'port': parsed.port,
-            }
-            # Remove None values
-            self.conn_kwargs = {k: v for k, v in self.conn_kwargs.items() if v is not None}
-        else:
-            # Handle sqlite:///path
-            self.db_path = db_url.replace("sqlite:///", "")
-            if not self.db_path:
-                self.db_path = "codegraphy.db"
-
-    @contextmanager
-    def get_connection(self):
-        if self.is_postgres:
-            conn = psycopg2.connect(**self.conn_kwargs)
-        else:
-            conn = sqlite3.connect(self.db_path)
-            conn.execute("PRAGMA foreign_keys = ON")
-            
-        try:
-            yield conn
-            conn.commit()
-        except Exception:
-            conn.rollback()
-            raise
-        finally:
-            conn.close()
-
-    def init_schema(self):
-        schema_sql = get_schema(self.db_url)
-        with self.get_connection() as conn:
-            cursor = conn.cursor()
-            if self.is_postgres:
-                cursor.execute(schema_sql)
-            else:
-                # sqlite3 executescript for multiple statements
-                cursor.executescript(schema_sql)
-
-    def get_file_hash(self, file_path: str) -> str:
-        with self.get_connection() as conn:
-            cursor = conn.cursor()
-            if self.is_postgres:
-                cursor.execute("SELECT git_hash FROM cg_files WHERE file_path = %s", (file_path,))
-            else:
-                cursor.execute("SELECT git_hash FROM cg_files WHERE file_path = ?", (file_path,))
-            row = cursor.fetchone()
-            return row[0] if row else None
-
-    def upsert_file(self, file_path: str, git_hash: str, symbols: list, edges: list):
-        """
-        Replace symbols and edges for a file.
-        """
-        with self.get_connection() as conn:
-            cursor = conn.cursor()
-            
-            # Param style
-            p = "%s" if self.is_postgres else "?"
-            
-            # Upsert file
-            if self.is_postgres:
-                cursor.execute(f"""
-                    INSERT INTO cg_files (file_path, git_hash, symbol_count, last_indexed)
-                    VALUES ({p}, {p}, {p}, NOW())
-                    ON CONFLICT (file_path) DO UPDATE 
-                    SET git_hash = EXCLUDED.git_hash, symbol_count = EXCLUDED.symbol_count, last_indexed = NOW()
-                """, (file_path, git_hash, len(symbols)))
-            else:
-                cursor.execute(f"""
-                    INSERT INTO cg_files (file_path, git_hash, symbol_count, last_indexed)
-                    VALUES ({p}, {p}, {p}, CURRENT_TIMESTAMP)
-                    ON CONFLICT(file_path) DO UPDATE 
-                    SET git_hash=excluded.git_hash, symbol_count=excluded.symbol_count, last_indexed=CURRENT_TIMESTAMP
-                """, (file_path, git_hash, len(symbols)))
-
-            # Delete old symbols (cascade deletes edges)
-            cursor.execute(f"DELETE FROM cg_symbols WHERE file_path = {p}", (file_path,))
-
-            # Insert new symbols
-            if symbols:
-                symbol_records = []
-                for s in symbols:
-                    extra_val = Json(s.extra) if self.is_postgres else json.dumps(s.extra)
-                    symbol_records.append((
-                        s.name, s.qualified_name, s.kind, s.file_path,
-                        s.line_start, s.line_end, s.summary, s.raw_signature, extra_val
-                    ))
-                
-                cursor.executemany(f"""
-                    INSERT INTO cg_symbols (name, qualified_name, kind, file_path, line_start, line_end, summary, raw_signature, extra)
-                    VALUES ({p}, {p}, {p}, {p}, {p}, {p}, {p}, {p}, {p})
-                """, symbol_records)
-
-            # To insert edges, we need their IDs. The simplest way is to map qualified_name -> id
-            # Note: For edges where the target doesn't exist yet, we might have missing IDs.
-            # To handle this robustly without failing, we only insert edges where both from and to exist.
-            # However, the spec says from_id, to_id.
-            # We must get IDs for all symbols first.
-            
-            # For simplicity in this step, we will bulk insert edges later or inside a second pass?
-            # Actually we can just look up ids.
-            # If to_qualified doesn't exist in DB, the edge is dropped.
-            if edges:
-                quals = set()
-                for e in edges:
-                    quals.add(e.from_qualified)
-                    quals.add(e.to_qualified)
-                
-                if quals:
-                    # SQLite limit for variables is 999, but a single file rarely exceeds that.
-                    # For safety, we can query in batches, or use placeholders.
-                    quals_list = list(quals)
-                    qual_to_id = {}
-                    
-                    # Batch fetch to avoid hitting sqlite limits
-                    batch_size = 500
-                    for i in range(0, len(quals_list), batch_size):
-                        batch = quals_list[i:i+batch_size]
-                        placeholders = ",".join([p] * len(batch))
-                        cursor.execute(f"SELECT id, qualified_name FROM cg_symbols WHERE qualified_name IN ({placeholders})", tuple(batch))
-                        for row in cursor.fetchall():
-                            qual_to_id[row[1]] = row[0]
-                    
-                    edge_records = []
-                    for e in edges:
-                        from_id = qual_to_id.get(e.from_qualified)
-                        to_id = qual_to_id.get(e.to_qualified)
-                        if from_id and to_id:
-                            edge_records.append((from_id, to_id, e.relation))
-                    
-                    if edge_records:
-                        cursor.executemany(f"""
-                            INSERT INTO cg_edges (from_id, to_id, relation)
-                            VALUES ({p}, {p}, {p})
-                            ON CONFLICT DO NOTHING
-                        """, edge_records)

codegraphy-0.1.1/codegraphy/indexer/walker.py

@@ -1,77 +0,0 @@
-import os
-import hashlib
-import subprocess
-from .python import PythonIndexer
-from ..db.store import Store
-
-INDEXERS = [PythonIndexer()]
-
-def sha256(content: bytes) -> str:
-    return hashlib.sha256(content).hexdigest()
-
-def get_files_to_index(root: str, exclude: list[str]) -> list[str]:
-    # Use git ls-files if possible
-    try:
-        result = subprocess.run(
-            ['git', 'ls-files'],
-            cwd=root,
-            capture_output=True,
-            text=True,
-            check=True
-        )
-        files = result.stdout.splitlines()
-        # Make paths absolute
-        files = [os.path.join(root, f) for f in files]
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        # Fallback to os.walk
-        files = []
-        for dirpath, dirnames, filenames in os.walk(root):
-            # rudimentary exclude
-            dirnames[:] = [d for d in dirnames if d not in exclude and not d.startswith('.')]
-            for f in filenames:
-                files.append(os.path.join(dirpath, f))
-    
-    # Filter excludes
-    if exclude:
-        filtered = []
-        for f in files:
-            if not any(ex in f for ex in exclude):
-                filtered.append(f)
-        files = filtered
-        
-    return files
-
-def index_path(root: str, store: Store, plugins: list, exclude: list[str] = None):
-    exclude = exclude or ['.git', 'node_modules', '__pycache__', '.venv']
-    files = get_files_to_index(root, exclude)
-    
-    indexed_count = 0
-    for path in files:
-        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()
-        except OSError:
-            continue
-            
-        file_hash = sha256(content_bytes)
-        
-        # Check if unchanged
-        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)
-        
-        # Apply plugins
-        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)
-        indexed_count += 1
-        
-    return indexed_count