scip-cli 1.0.2__tar.gz → 1.1.0__tar.gz

{scip_cli-1.0.2/scip_cli.egg-info → scip_cli-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scip-cli
-Version: 1.0.2
+Version: 1.1.0
 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
@@ -40,10 +40,27 @@ Fast code intelligence CLI for TypeScript/JavaScript projects. Query SCIP indexe
 
 ### 1. Install scip-cli
 
+**From PyPI:**
+
 ```bash
 pip install scip-cli
 ```
 
+**From source (local development):**
+
+```bash
+git clone https://github.com/flesler/scip-cli.git
+cd scip-cli
+pip install .
+```
+
+For editable development (where `pip install -e .` fails due to permissions):
+
+```bash
+export PYTHONPATH=/path/to/scip-cli:$PYTHONPATH
+python -m scip_cli --help
+```
+
 ### 2. Install prerequisites (optional)
 
 scip-cli can automatically download the required indexing tools when needed, or you can install them globally for faster performance:
@@ -55,10 +72,13 @@ Just use scip-cli - it will automatically download the required tools via `npx`
 **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
 ```
 
@@ -70,12 +90,6 @@ 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`:
@@ -92,6 +106,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
@@ -121,14 +136,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)
@@ -136,6 +153,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
 
 ```
@@ -150,9 +169,23 @@ scip_cli/
     ├── symbols.py
     ├── rdeps.py
     ├── members.py
+    ├── reindex.py
     └── skill.py
 ```
 
+## Development
+
+### Debug Logging
+
+Set `SCIP_CLI_DEBUG=1` to enable SQL query logging to stderr:
+
+```bash
+SCIP_CLI_DEBUG=1 scip-cli refs MyFunction
+# Shows: SQL: SELECT ... | params: (...)
+```
+
+This is useful for testing and debugging SQL queries without exposing a `--debug` flag to users.
+
 ## License
 
 MIT

{scip_cli-1.0.2 → scip_cli-1.1.0}/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
@@ -16,10 +16,27 @@ Fast code intelligence CLI for TypeScript/JavaScript projects. Query SCIP indexe
 
 ### 1. Install scip-cli
 
+**From PyPI:**
+
 ```bash
 pip install scip-cli
 ```
 
+**From source (local development):**
+
+```bash
+git clone https://github.com/flesler/scip-cli.git
+cd scip-cli
+pip install .
+```
+
+For editable development (where `pip install -e .` fails due to permissions):
+
+```bash
+export PYTHONPATH=/path/to/scip-cli:$PYTHONPATH
+python -m scip_cli --help
+```
+
 ### 2. Install prerequisites (optional)
 
 scip-cli can automatically download the required indexing tools when needed, or you can install them globally for faster performance:
@@ -31,10 +48,13 @@ Just use scip-cli - it will automatically download the required tools via `npx`
 **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
 ```
 
@@ -46,12 +66,6 @@ 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`:
@@ -68,6 +82,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
@@ -97,14 +112,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)
@@ -112,6 +129,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
 
 ```
@@ -126,9 +145,23 @@ scip_cli/
     ├── symbols.py
     ├── rdeps.py
     ├── members.py
+    ├── reindex.py
     └── skill.py
 ```
 
+## Development
+
+### Debug Logging
+
+Set `SCIP_CLI_DEBUG=1` to enable SQL query logging to stderr:
+
+```bash
+SCIP_CLI_DEBUG=1 scip-cli refs MyFunction
+# Shows: SQL: SELECT ... | params: (...)
+```
+
+This is useful for testing and debugging SQL queries without exposing a `--debug` flag to users.
+
 ## License
 
 MIT

{scip_cli-1.0.2 → scip_cli-1.1.0}/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.
 
@@ -11,8 +11,8 @@ All commands are sub-commands of `scip-cli`. Run from the project root.
 
 | Question | Use | What you get |
 |----------|-----|--------------|
-| "Where is X defined and what does it do?" | `def X` | Functions: full body. Classes: full definition. Multiple exact matches returned together |
-| "Where is X used/called?" | `refs X` | All file:line locations (~0.03s). Ambiguous bare names → first match only |
+| "Where is X defined and what does it do?" | `def X` | Functions: full body. Classes: full definition. Use `--limit` to cap results |
+| "Where is X used/called?" | `refs X` | All file:line locations. Shows refs for all matching symbols. Use `--limit` to cap |
 | "What's in this file?" | `symbols file` | All symbols — bare filename works (`HistoryTab`, `usePatientEntries`) |
 | "Find symbols by name" | `search name` | Functions, types, interfaces, classes. Use `--kind variable` for consts |
 | "What files depend on this file?" | `rdeps file` | Importers — bare name works |
@@ -20,53 +20,62 @@ 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 matches; `refs` returns refs for all matching symbols. Use `--limit N` to cap results, or 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>] [--limit N] <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.
+
+Default `--limit` is 10. Use `--limit 0` for unlimited (not recommended for large codebases).
 
 ### refs
 
 ```bash
-refs <symbol>
+refs [--limit N] <symbol>
 ```
 
 Returns `file:line` for each reference. Reads source files to find exact line numbers.
 
+Default `--limit` is 10. When multiple symbols match, refs are grouped by symbol with `# <symbol>` headers.
+
 ### search
 
 ```bash
-search [--kind <kind>] <pattern>
+search [--kind <kind>] [--limit N] <pattern>
 ```
 
 Returns `file:line Kind symbolName`. Filters noisy symbols (file-level, parameters, type literals).
 
+Default `--limit` is 10.
+
 ### symbols
 
 ```bash
-symbols <file>
+symbols [--limit N] <file>
 ```
 
 Returns `startLine-endLine kind name` for each symbol in the file.
 
+Default `--limit` is 10.
+
 ### rdeps
 
 ```bash
-rdeps <file>
+rdeps [--limit N] <file>
 ```
 
 Returns list of files that import from this file.
 
+Default `--limit` is 10.
+
 ### members
 
 ```bash

{scip_cli-1.0.2 → scip_cli-1.1.0}/scip_cli/__init__.py

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

{scip_cli-1.0.2 → scip_cli-1.1.0}/scip_cli/__main__.py

@@ -1,10 +1,22 @@
-#!/usr/bin/env python3
 """CLI entry point for scip-cli."""
 import argparse
+import logging
+import os
 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
+
+# Set up debug logging based on SCIP_CLI_DEBUG env var
+if os.environ.get("SCIP_CLI_DEBUG"):
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(name)s: %(message)s",
+        stream=sys.stderr
+    )
+else:
+    logging.disable(logging.DEBUG)
 
 
 def main():
@@ -18,23 +30,28 @@ def main():
     # refs
     refs_parser = subparsers.add_parser("refs", help="Find references to a symbol")
     refs_parser.add_argument("symbol", help="Symbol name")
+    refs_parser.add_argument("--limit", type=int, default=10, help="Max results (default: 10)")
 
     # 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("--limit", type=int, default=10, help="Max results (default: 10)")
     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("--limit", type=int, default=10, help="Max results (default: 10)")
     search_parser.add_argument("pattern", help="Search pattern")
 
     # symbols
     symbols_parser = subparsers.add_parser("symbols", help="List symbols in a file")
+    symbols_parser.add_argument("--limit", type=int, default=10, help="Max results (default: 10)")
     symbols_parser.add_argument("file", help="File path or pattern")
 
     # rdeps
     rdeps_parser = subparsers.add_parser("rdeps", help="Find reverse dependencies of a file")
+    rdeps_parser.add_argument("--limit", type=int, default=10, help="Max results (default: 10)")
     rdeps_parser.add_argument("file", help="File path or pattern")
 
     # members
@@ -45,27 +62,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.1.0/scip_cli/commands/def_cmd.py

@@ -0,0 +1,47 @@
+"""def command - find symbol definitions."""
+import sys
+
+from ..lib import (
+    setup,
+    resolve_symbol,
+    read_source_lines,
+    infer_kind,
+    get_def_location,
+    format_line_range,
+)
+
+
+def main(args):
+    """Find the definition of a symbol."""
+    db, project_root = setup()
+    try:
+        limit = args.limit
+        symbols = resolve_symbol(db, args.symbol, args.kind, limit=limit + 1)
+        if not symbols:
+            print(f"Symbol '{args.symbol}' not found", file=sys.stderr)
+            sys.exit(1)
+
+        hit_limit = len(symbols) > limit
+        symbols = symbols[:limit]
+
+        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}:{format_line_range(start_line, end_line)}")
+            print(source_snippet)
+
+        if hit_limit:
+            print(f"# Warning: more than {limit} symbols match, showing first {limit}", file=sys.stderr)
+    finally:
+        db.close()

scip_cli-1.1.0/scip_cli/commands/members.py

@@ -0,0 +1,86 @@
+"""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,
+    format_line_range,
+    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 = format_line_range(start_line, end_line)
+            print(f"{line_info} {kind} {short}")
+    finally:
+        db.close()

scip_cli-1.1.0/scip_cli/commands/rdeps.py

@@ -0,0 +1,47 @@
+"""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:
+        limit = args.limit
+        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)
+
+        sorted_rdeps = sorted(rdeps)
+        hit_limit = len(sorted_rdeps) > limit
+        sorted_rdeps = sorted_rdeps[:limit]
+
+        for dep_path in sorted_rdeps:
+            print(dep_path)
+
+        if hit_limit:
+            print(f"# Warning: more than {limit} reverse dependencies, showing first {limit}", file=sys.stderr)
+    finally:
+        db.close()