scip-cli 1.0.1__tar.gz → 1.0.3__tar.gz

{scip_cli-1.0.1/scip_cli.egg-info → scip_cli-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scip-cli
-Version: 1.0.1
+Version: 1.0.3
 Summary: Fast code intelligence via SCIP indexes
 Home-page: https://github.com/flesler/scip-cli
 Author: Ariel Flesler
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Code Generators
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author
@@ -27,11 +27,11 @@ Dynamic: summary
 [![PyPI version](https://badge.fury.io/py/scip-cli.svg)](https://badge.fury.io/py/scip-cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Fast code intelligence CLI for TypeScript/JavaScript projects. Query SCIP indexes directly via SQLite for instant results.
+Fast code intelligence CLI for TypeScript/JavaScript and Python projects. Query SCIP indexes directly via SQLite for instant results.
 
 ## Features
 
-- **Fast**: Direct SQLite queries, 100-500x faster than bash wrappers
+- **Fast**: Direct SQLite queries, eliminating skippable overhead
 - **Simple**: Single binary with subcommands
 - **Auto-indexing**: Automatically indexes projects on first query
 - **Token-efficient**: Clean, minimal output optimized for AI consumption
@@ -44,17 +44,24 @@ Fast code intelligence CLI for TypeScript/JavaScript projects. Query SCIP indexe
 pip install scip-cli
 ```
 
-### 2. Install prerequisites
+### 2. Install prerequisites (optional)
 
-scip-cli requires two external tools for indexing:
+scip-cli can automatically download the required indexing tools when needed, or you can install them globally for faster performance:
 
-**For TypeScript/JavaScript projects:**
+**Option A: Let scip-cli handle it (recommended)**
+
+Just use scip-cli - it will automatically download the required tools via `npx` on first use. No global installation needed.
+
+**Option B: Install globally for better performance**
 
 ```bash
-# Install scip-typescript (SCIP indexer)
+# TypeScript/JavaScript indexer (also handles plain JS via --infer-tsconfig)
 npm install -g @sourcegraph/scip-typescript
 
-# Install scip (SCIP CLI for index conversion)
+# Python indexer
+npm install -g @sourcegraph/scip-python
+
+# SCIP CLI for index conversion
 npm install -g @sourcegraph/scip
 ```
 
@@ -62,16 +69,10 @@ npm install -g @sourcegraph/scip
 
 ```bash
 scip-cli --help
-scip-typescript --version
-scip --version
+scip-typescript --version  # Only if you chose Option B
+scip --version             # Only if you chose Option B
 ```
 
-## Prerequisites
-
-- Python 3.7+
-- `scip-typescript` (for indexing TypeScript/JavaScript)
-- `scip` CLI (for converting indexes)
-
 ## Usage
 
 All commands are subcommands of `scip-cli`:
@@ -88,6 +89,7 @@ scip-cli <command> [arguments]
 - `symbols <file>` - List all symbols in a file
 - `rdeps <file>` - Find files that depend on a file
 - `members <symbol>` - List members of a class/interface
+- `reindex` - Force re-indexing of the current project
 - `skill [path]` - Install or dump the SKILL.md
 
 ### Examples
@@ -117,14 +119,16 @@ scip-cli skill ~/.claude/skills/scip/SKILL.md
 
 ## How It Works
 
-1. On first query, automatically indexes the project using `scip-typescript`
-2. Converts the SCIP index to SQLite using `scip expt-convert`
-3. Caches the database in `~/.cache/scip-query/projects/<hash>/index.db`
-4. Subsequent queries are instant SQLite lookups
+1. On first query, automatically detects project language from `package.json` (TS/JS) or `pyproject.toml`/`setup.py` (Python)
+2. Indexes using `scip-typescript` (adds `--infer-tsconfig` for JS-only projects) or `scip-python`
+3. Converts the SCIP index to SQLite using `scip expt-convert`
+4. Caches the database in `~/.cache/scip-cli/projects/<hash>/index.db`
+5. Subsequent queries are instant SQLite lookups
 
 ## Performance
 
-Compared to bash wrappers:
+Inspired by [scip-query](https://github.com/PlunderStruck/scip-query), scip-cli is a lightweight Python reimplementation optimized for speed. Compared to the original bash wrapper scripts:
+
 - `refs`: 6.4s → 0.03s (213x faster)
 - `def`: 2.8s → 0.05s (56x faster)
 - `search`: 2.6s → 0.03s (87x faster)
@@ -132,6 +136,8 @@ Compared to bash wrappers:
 - `rdeps`: 0.2s → 0.02s (10x faster)
 - `members`: 3.1s → 0.03s (103x faster)
 
+The speedup comes from direct SQLite queries instead of shell command chains, eliminating subprocess overhead.
+
 ## Architecture
 
 ```
@@ -146,6 +152,7 @@ scip_cli/
     ├── symbols.py
     ├── rdeps.py
     ├── members.py
+    ├── reindex.py
     └── skill.py
 ```
 

{scip_cli-1.0.1 → scip_cli-1.0.3}/README.md

@@ -3,11 +3,11 @@
 [![PyPI version](https://badge.fury.io/py/scip-cli.svg)](https://badge.fury.io/py/scip-cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Fast code intelligence CLI for TypeScript/JavaScript projects. Query SCIP indexes directly via SQLite for instant results.
+Fast code intelligence CLI for TypeScript/JavaScript and Python projects. Query SCIP indexes directly via SQLite for instant results.
 
 ## Features
 
-- **Fast**: Direct SQLite queries, 100-500x faster than bash wrappers
+- **Fast**: Direct SQLite queries, eliminating skippable overhead
 - **Simple**: Single binary with subcommands
 - **Auto-indexing**: Automatically indexes projects on first query
 - **Token-efficient**: Clean, minimal output optimized for AI consumption
@@ -20,17 +20,24 @@ Fast code intelligence CLI for TypeScript/JavaScript projects. Query SCIP indexe
 pip install scip-cli
 ```
 
-### 2. Install prerequisites
+### 2. Install prerequisites (optional)
 
-scip-cli requires two external tools for indexing:
+scip-cli can automatically download the required indexing tools when needed, or you can install them globally for faster performance:
 
-**For TypeScript/JavaScript projects:**
+**Option A: Let scip-cli handle it (recommended)**
+
+Just use scip-cli - it will automatically download the required tools via `npx` on first use. No global installation needed.
+
+**Option B: Install globally for better performance**
 
 ```bash
-# Install scip-typescript (SCIP indexer)
+# TypeScript/JavaScript indexer (also handles plain JS via --infer-tsconfig)
 npm install -g @sourcegraph/scip-typescript
 
-# Install scip (SCIP CLI for index conversion)
+# Python indexer
+npm install -g @sourcegraph/scip-python
+
+# SCIP CLI for index conversion
 npm install -g @sourcegraph/scip
 ```
 
@@ -38,16 +45,10 @@ npm install -g @sourcegraph/scip
 
 ```bash
 scip-cli --help
-scip-typescript --version
-scip --version
+scip-typescript --version  # Only if you chose Option B
+scip --version             # Only if you chose Option B
 ```
 
-## Prerequisites
-
-- Python 3.7+
-- `scip-typescript` (for indexing TypeScript/JavaScript)
-- `scip` CLI (for converting indexes)
-
 ## Usage
 
 All commands are subcommands of `scip-cli`:
@@ -64,6 +65,7 @@ scip-cli <command> [arguments]
 - `symbols <file>` - List all symbols in a file
 - `rdeps <file>` - Find files that depend on a file
 - `members <symbol>` - List members of a class/interface
+- `reindex` - Force re-indexing of the current project
 - `skill [path]` - Install or dump the SKILL.md
 
 ### Examples
@@ -93,14 +95,16 @@ scip-cli skill ~/.claude/skills/scip/SKILL.md
 
 ## How It Works
 
-1. On first query, automatically indexes the project using `scip-typescript`
-2. Converts the SCIP index to SQLite using `scip expt-convert`
-3. Caches the database in `~/.cache/scip-query/projects/<hash>/index.db`
-4. Subsequent queries are instant SQLite lookups
+1. On first query, automatically detects project language from `package.json` (TS/JS) or `pyproject.toml`/`setup.py` (Python)
+2. Indexes using `scip-typescript` (adds `--infer-tsconfig` for JS-only projects) or `scip-python`
+3. Converts the SCIP index to SQLite using `scip expt-convert`
+4. Caches the database in `~/.cache/scip-cli/projects/<hash>/index.db`
+5. Subsequent queries are instant SQLite lookups
 
 ## Performance
 
-Compared to bash wrappers:
+Inspired by [scip-query](https://github.com/PlunderStruck/scip-query), scip-cli is a lightweight Python reimplementation optimized for speed. Compared to the original bash wrapper scripts:
+
 - `refs`: 6.4s → 0.03s (213x faster)
 - `def`: 2.8s → 0.05s (56x faster)
 - `search`: 2.6s → 0.03s (87x faster)
@@ -108,6 +112,8 @@ Compared to bash wrappers:
 - `rdeps`: 0.2s → 0.02s (10x faster)
 - `members`: 3.1s → 0.03s (103x faster)
 
+The speedup comes from direct SQLite queries instead of shell command chains, eliminating subprocess overhead.
+
 ## Architecture
 
 ```
@@ -122,6 +128,7 @@ scip_cli/
     ├── symbols.py
     ├── rdeps.py
     ├── members.py
+    ├── reindex.py
     └── skill.py
 ```
 

{scip_cli-1.0.1 → scip_cli-1.0.3}/scip_cli/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: scip-cli
-description: Read when needing to find symbols, definitions, references, or members in TypeScript/JavaScript code
+description: Read when needing to find symbols, definitions, references, or members in TypeScript/JavaScript or Python code
 ---
 
-TypeScript/JavaScript only (.ts, .tsx, .js, .jsx) — not GraphQL, CSS, or other files.
+TypeScript/JavaScript (.ts, .tsx, .js, .jsx) and Python (.py) — not GraphQL, CSS, or other files.
 
 All commands are sub-commands of `scip-cli`. Run from the project root.
 
@@ -20,20 +20,19 @@ All commands are sub-commands of `scip-cli`. Run from the project root.
 
 ## Gotchas
 
-- **Bare names** resolve functions, types (aliases + interfaces), and classes. Consts/variables need `def --type variable X` or `search --kind variable X`. Class methods need `members ClassName`, not bare `def methodName`.
-- **Ambiguous types** (e.g. `Opts` in multiple hooks) — `def` returns all; `refs` picks the first and warns. Use `search` or a qualified `src:…` name to disambiguate.
-- **First run** in a project may auto-index (one-time wait, ~10-30s for large codebases).
-- **Precision escape hatch**: qualified names like `src:hooks:usePatientEntries:usePatientEntries()` always work.
+- **Bare names** resolve functions, types (aliases + interfaces), and classes. Consts/variables need `def --kind variable X` or `search --kind variable X`. Class methods need `members ClassName`, not bare `def methodName`.
+- **Ambiguous types** (e.g. `Opts` in multiple hooks) — `def` returns all; `refs` picks the first and warns. Use `search` with a more specific pattern to disambiguate.
+- **First run** in a project may auto-index (one-time wait, ~10-30s for large codebases). JS-only projects (no `tsconfig.json`) are supported automatically.
 
 ## Details
 
 ### def
 
 ```bash
-def [--type <kind>] <symbol>
+def [--kind <kind>] <symbol>
 ```
 
-Kinds: `function`, `class`, `interface`, `type`, `method`, `variable` — use `--type` when the bare name isn't in the default set above.
+Kinds: `function`, `method`, `class`, `property`, `variable` — use `--kind` when the bare name isn't in the default set above.
 
 ### refs
 

{scip_cli-1.0.1 → scip_cli-1.0.3}/scip_cli/__init__.py

@@ -1,2 +1,2 @@
 """scip-cli: Fast code intelligence via SCIP indexes."""
-__version__ = "1.0.1"
+__version__ = "1.0.3"

{scip_cli-1.0.1 → scip_cli-1.0.3}/scip_cli/__main__.py

@@ -1,10 +1,10 @@
-#!/usr/bin/env python3
 """CLI entry point for scip-cli."""
 import argparse
 import sys
 
 from . import __version__
-from .commands import refs, def_cmd, search, symbols, rdeps, members, skill
+from .lib import SymbolKind
+from .commands import refs, def_cmd, search, symbols, rdeps, members, skill, reindex
 
 
 def main():
@@ -21,12 +21,12 @@ def main():
 
     # def
     def_parser = subparsers.add_parser("def", help="Find symbol definition")
-    def_parser.add_argument("--type", dest="kind", help="Filter by kind (function, class, etc)")
+    def_parser.add_argument("--kind", choices=SymbolKind.filterable_values(), help="Filter by kind")
     def_parser.add_argument("symbol", help="Symbol name")
 
     # search
     search_parser = subparsers.add_parser("search", help="Search symbols by pattern")
-    search_parser.add_argument("--kind", help="Filter by kind")
+    search_parser.add_argument("--kind", choices=SymbolKind.filterable_values(), help="Filter by kind")
     search_parser.add_argument("pattern", help="Search pattern")
 
     # symbols
@@ -45,27 +45,35 @@ def main():
     skill_parser = subparsers.add_parser("skill", help="Install or dump the scip-cli SKILL.md")
     skill_parser.add_argument("path", nargs="?", help="Optional file path to write to (creates dirs)")
 
+    # reindex
+    subparsers.add_parser("reindex", help="Force re-indexing of the current project")
+
     args = parser.parse_args()
 
-    if not args.command:
+    # Dispatch to command handlers
+    dispatch = {
+        "refs": refs.main,
+        "def": def_cmd.main,
+        "search": search.main,
+        "symbols": symbols.main,
+        "rdeps": rdeps.main,
+        "members": members.main,
+        "skill": skill.main,
+        "reindex": reindex.main,
+    }
+
+    handler = dispatch.get(args.command)
+    if not handler:
         parser.print_help()
         sys.exit(1)
 
-    # Dispatch to command handlers
-    if args.command == "refs":
-        refs.main(args)
-    elif args.command == "def":
-        def_cmd.main(args)
-    elif args.command == "search":
-        search.main(args)
-    elif args.command == "symbols":
-        symbols.main(args)
-    elif args.command == "rdeps":
-        rdeps.main(args)
-    elif args.command == "members":
-        members.main(args)
-    elif args.command == "skill":
-        skill.main(args)
+    try:
+        handler(args)
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        sys.exit(130)
 
 
 if __name__ == "__main__":

scip_cli-1.0.3/scip_cli/commands/def_cmd.py

@@ -0,0 +1,39 @@
+"""def command - find symbol definitions."""
+import sys
+
+from ..lib import (
+    setup,
+    resolve_symbol,
+    read_source_lines,
+    infer_kind,
+    get_def_location,
+)
+
+
+def main(args):
+    """Find the definition of a symbol."""
+    db, project_root = setup()
+    try:
+        symbols = resolve_symbol(db, args.symbol, args.kind)
+        if not symbols:
+            print(f"Symbol '{args.symbol}' not found", file=sys.stderr)
+            sys.exit(1)
+
+        for symbol_id, symbol_str, display_name in symbols:
+            row = get_def_location(db, symbol_id)
+            if not row:
+                continue
+
+            rel_path, start_line, end_line = row
+            kind = infer_kind(symbol_str)
+
+            lines = read_source_lines(project_root, rel_path, start_line, end_line)
+            if lines is None:
+                source_snippet = "(could not read source)"
+            else:
+                source_snippet = ''.join(lines).rstrip('\n')
+
+            print(f"{rel_path}:{start_line + 1}:{end_line + 1}")
+            print(source_snippet)
+    finally:
+        db.close()

scip_cli-1.0.3/scip_cli/commands/members.py

@@ -0,0 +1,85 @@
+"""members command - list members of a class/interface."""
+import sys
+import re
+
+from ..lib import (
+    setup,
+    resolve_one_symbol,
+    get_members,
+    get_def_location,
+    infer_kind,
+    extract_leaf_name,
+    read_source_lines,
+    SymbolKind,
+)
+
+
+def _member_source_patterns(member_symbol, short, kind):
+    """Build TS/JS and Python regex patterns for finding a member's source line."""
+    if "<constructor>" in member_symbol:
+        ts_pattern = r'^\s*constructor\s*\('
+    elif "<get>" in member_symbol:
+        ts_pattern = rf'^\s*(?:public\s+|private\s+|protected\s+|static\s+|readonly\s+)*get\s+{re.escape(short)}\s*\('
+    elif "<set>" in member_symbol:
+        ts_pattern = rf'^\s*(?:public\s+|private\s+|protected\s+|static\s+|readonly\s+)*set\s+{re.escape(short)}\s*\('
+    else:
+        ts_pattern = rf'^\s*(?:public\s+|private\s+|protected\s+|static\s+|readonly\s+)*{re.escape(short)}\s*\??\s*[:=(]'
+
+    py_pattern = None
+    if kind == SymbolKind.METHOD:
+        py_pattern = rf'^\s*(?:async\s+)?def\s+{re.escape(short)}\s*\('
+    elif kind == SymbolKind.PROPERTY:
+        py_pattern = rf'^\s*{re.escape(short)}\s*[=:]'
+    elif kind == SymbolKind.CLASS:
+        py_pattern = rf'^\s*class\s+{re.escape(short)}\s*[:\(]'
+
+    return ts_pattern, py_pattern
+
+
+def main(args):
+    """List members of a class or interface."""
+    db, project_root = setup()
+    try:
+        symbol_id, _, _ = resolve_one_symbol(db, args.symbol)
+        members = get_members(db, symbol_id)
+
+        if not members:
+            print(f"No members found for '{args.symbol}'", file=sys.stderr)
+            sys.exit(1)
+
+        parent_def = get_def_location(db, symbol_id)
+        parent_file = parent_def[0] if parent_def else None
+        parent_start = parent_def[1] if parent_def else None
+        parent_end = parent_def[2] if parent_def else None
+
+        needs_lookup = any(m[3] is None for m in members)
+        source_lines = None
+        if needs_lookup and project_root and parent_file and parent_start is not None:
+            source_lines = read_source_lines(project_root, parent_file, parent_start, parent_end)
+
+        for member_id, member_symbol, member_name, start_line, end_line in members:
+            kind = infer_kind(member_symbol)
+            short = extract_leaf_name(member_symbol)
+
+            if start_line is None and source_lines:
+                ts_pattern, py_pattern = _member_source_patterns(member_symbol, short, kind)
+                patterns = []
+                if parent_file and parent_file.endswith('.py'):
+                    if py_pattern:
+                        patterns.append(py_pattern)
+                    patterns.append(ts_pattern)
+                else:
+                    patterns.append(ts_pattern)
+                    if py_pattern:
+                        patterns.append(py_pattern)
+
+                for i, line in enumerate(source_lines):
+                    if any(re.match(p, line) for p in patterns):
+                        start_line = parent_start + i
+                        end_line = start_line
+                        break
+
+            line_info = f"{start_line + 1}:{end_line + 1}" if start_line is not None else "??"
+            print(f"{line_info} {kind} {short}")
+    finally:
+        db.close()

scip_cli-1.0.3/scip_cli/commands/rdeps.py

@@ -0,0 +1,39 @@
+"""rdeps command - find reverse dependencies of a file."""
+import sys
+
+from ..lib import (
+    setup,
+    resolve_one_file,
+    get_file_symbols,
+    get_refs_for_symbols,
+)
+
+
+def main(args):
+    """Find all files that import from this file."""
+    db, _ = setup()
+    try:
+        file_path = resolve_one_file(db, args.file)
+
+        symbols = get_file_symbols(db, file_path)
+        if not symbols:
+            print(f"No symbols found in '{file_path}'", file=sys.stderr)
+            sys.exit(1)
+
+        symbol_ids = [s[0] for s in symbols]
+        refs = get_refs_for_symbols(db, symbol_ids)
+
+        rdeps = set()
+        for symbol_id, ref_list in refs.items():
+            for ref_path, ref_line in ref_list:
+                if ref_path != file_path:
+                    rdeps.add(ref_path)
+
+        if not rdeps:
+            print(f"No reverse dependencies found for '{file_path}'", file=sys.stderr)
+            sys.exit(1)
+
+        for dep_path in sorted(rdeps):
+            print(dep_path)
+    finally:
+        db.close()

{scip_cli-1.0.1 → scip_cli-1.0.3}/scip_cli/commands/refs.py

@@ -2,10 +2,8 @@
 import sys
 
 from ..lib import (
-    get_db,
-    resolve_symbol,
-    warn_ambiguous,
-    find_project_root,
+    setup,
+    resolve_one_symbol,
     read_source_lines,
     extract_leaf_name,
 )
@@ -13,14 +11,12 @@ from ..lib import (
 
 def get_exact_refs(db, symbol_id, project_root):
     """Get references with exact line numbers by reading source files."""
-    # Get symbol name once
     sym_row = db.execute("SELECT symbol FROM global_symbols WHERE id = ?", (symbol_id,)).fetchone()
     if not sym_row:
         return []
-    
+
     leaf = extract_leaf_name(sym_row[0])
-    
-    # Get all chunks that reference this symbol
+
     chunks = db.execute("""
         SELECT c.id, c.document_id, c.start_line, c.end_line, d.relative_path
         FROM mentions m
@@ -28,80 +24,60 @@ def get_exact_refs(db, symbol_id, project_root):
         JOIN documents d ON c.document_id = d.id
         WHERE m.symbol_id = ? AND m.role != 1
     """, (symbol_id,)).fetchall()
-    
+
     if not chunks:
         return []
-    
-    # Group by document
+
     by_doc = {}
     for chunk_id, doc_id, start_line, end_line, rel_path in chunks:
         if doc_id not in by_doc:
             by_doc[doc_id] = {'path': rel_path, 'chunks': []}
         by_doc[doc_id]['chunks'].append((chunk_id, start_line, end_line))
-    
+
     results = []
-    
-    # For each document, read source and find exact lines
+
     for doc_id, info in by_doc.items():
         rel_path = info['path']
-        
-        # Get min/max line range for this document
         min_line = min(c[1] for c in info['chunks'])
         max_line = max(c[2] for c in info['chunks'])
-        
-        # Read only the needed range
+
         lines = read_source_lines(project_root, rel_path, min_line, max_line)
         if lines is None:
-            # If can't read file, fall back to chunk start lines
             for chunk_id, start_line, end_line in info['chunks']:
                 results.append((rel_path, start_line + 1))
             continue
-        
-        # Search for the symbol in each chunk's line range
+
         for chunk_id, start_line, end_line in info['chunks']:
-            # Search within the chunk range (adjusted for offset)
             offset = min_line
+            found = False
             for line_idx in range(start_line - offset, min(end_line - offset + 1, len(lines))):
-                line = lines[line_idx]
-                # Simple check: does the line contain the symbol name?
-                if leaf in line:
+                if leaf in lines[line_idx]:
                     results.append((rel_path, line_idx + offset + 1))
-                    break  # One match per chunk is enough
-            else:
-                # Fallback to chunk start line
+                    found = True
+                    break
+            if not found:
                 results.append((rel_path, start_line + 1))
-    
+
     return results
 
 
 def main(args):
     """Find all references to a symbol."""
-    db = get_db()
-    
-    symbols = resolve_symbol(db, args.symbol)
-    if not symbols:
-        print(f"Symbol '{args.symbol}' not found", file=sys.stderr)
-        sys.exit(1)
-    
-    warn_ambiguous(args.symbol, symbols, "symbol")
-    
-    symbol_id, symbol_str, display_name = symbols[0]
-    
-    project_root = find_project_root()
-    if not project_root:
-        print("Error: Could not find project root", file=sys.stderr)
-        sys.exit(1)
-    
-    refs = get_exact_refs(db, symbol_id, project_root)
-    
-    if not refs:
-        print(f"No references found for '{args.symbol}'", file=sys.stderr)
-        sys.exit(1)
-    
-    # Deduplicate and sort
-    seen = set()
-    for path, line in refs:
-        key = (path, line)
-        if key not in seen:
-            seen.add(key)
-            print(f"{path}:{line}")
+    db, project_root = setup()
+    try:
+        symbol_id, _, _ = resolve_one_symbol(db, args.symbol)
+
+        refs = get_exact_refs(db, symbol_id, project_root)
+
+        if not refs:
+            print(f"No references found for '{args.symbol}'", file=sys.stderr)
+            sys.exit(1)
+
+        seen = set()
+        for path, line in refs:
+            key = (path, line)
+            if key not in seen:
+                seen.add(key)
+                print(f"{path}:{line}")
+    finally:
+        db.close()