aja-codeintel 0.1.0__py3-none-any.whl

codeintel_cli/db/operations.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import hashlib
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+def _hash_content(content: str) -> str:
+    return hashlib.md5(content.encode("utf-8")).hexdigest()
+
+
+def get_file_modified_time(path: Path) -> float:
+    try:
+        return path.stat().st_mtime
+    except Exception:
+        return 0.0
+
+
+def is_file_cached(conn: sqlite3.Connection, path: Path) -> bool:
+    cursor = conn.execute("SELECT modified_time FROM files WHERE path = ?", (str(path.resolve()),))
+    row = cursor.fetchone()
+    if not row:
+        return False
+    cached_mtime = float(row[0])
+    current_mtime = float(get_file_modified_time(path))
+    return abs(cached_mtime - current_mtime) < 0.01
+
+
+def get_file_id(conn: sqlite3.Connection, path: Path) -> int | None:
+    cursor = conn.execute("SELECT id FROM files WHERE path = ?", (str(path.resolve()),))
+    row = cursor.fetchone()
+    return int(row[0]) if row else None
+
+
+def upsert_file(conn: sqlite3.Connection, path: Path, rel_path: str, language: str, content: str = "") -> int:
+    path_str = str(path.resolve())
+    file_id = get_file_id(conn, Path(path_str))
+    modified_time = get_file_modified_time(Path(path_str))
+    scanned_at = datetime.now().timestamp()
+    content_hash = _hash_content(content) if content else None
+
+    if file_id:
+        conn.execute(
+            "UPDATE files SET rel_path = ?, language = ?, modified_time = ?, scanned_at = ?, content_hash = ? WHERE id = ?",
+            (rel_path, language, modified_time, scanned_at, content_hash, file_id),
+        )
+        return file_id
+
+    cur = conn.execute(
+        "INSERT INTO files (path, rel_path, language, modified_time, scanned_at, content_hash) VALUES (?, ?, ?, ?, ?, ?)",
+        (path_str, rel_path, language, modified_time, scanned_at, content_hash),
+    )
+    return int(cur.lastrowid)
+
+
+def clear_file_data(conn: sqlite3.Connection, file_id: int) -> None:
+    conn.execute("DELETE FROM imports WHERE file_id = ?", (file_id,))
+    conn.execute("DELETE FROM symbols WHERE file_id = ?", (file_id,))
+    cur = conn.execute("SELECT id FROM models WHERE file_id = ?", (file_id,))
+    mids = [int(r[0]) for r in cur.fetchall()]
+    for mid in mids:
+        conn.execute("DELETE FROM model_fields WHERE model_id = ?", (mid,))
+        conn.execute("DELETE FROM relationships WHERE model_id = ?", (mid,))
+    conn.execute("DELETE FROM models WHERE file_id = ?", (file_id,))
+
+
+def insert_import(conn: sqlite3.Connection, file_id: int, import_path: str, resolved_file_id: int | None = None) -> None:
+    conn.execute(
+        "INSERT INTO imports (file_id, import_path, resolved_file_id) VALUES (?, ?, ?)",
+        (file_id, import_path, resolved_file_id),
+    )
+
+
+def update_import_resolved(conn: sqlite3.Connection, import_row_id: int, resolved_file_id: int) -> None:
+    conn.execute("UPDATE imports SET resolved_file_id = ? WHERE id = ?", (resolved_file_id, import_row_id))
+
+
+def insert_symbol(conn: sqlite3.Connection, file_id: int, name: str, symbol_type: str, line_number: int | None = None) -> None:
+    conn.execute(
+        "INSERT INTO symbols (file_id, name, type, line_number) VALUES (?, ?, ?, ?)",
+        (file_id, name, symbol_type, line_number),
+    )
+
+
+def insert_model(
+    conn: sqlite3.Connection,
+    file_id: int,
+    model_name: str,
+    fields: list[tuple[str, str, bool]],
+    relationships: list[dict[str, Any]],
+) -> int:
+    cur = conn.execute("INSERT INTO models (file_id, name) VALUES (?, ?)", (file_id, model_name))
+    model_id = int(cur.lastrowid)
+
+    for field_name, field_type, is_pk in fields:
+        conn.execute(
+            "INSERT INTO model_fields (model_id, name, type, is_primary_key) VALUES (?, ?, ?, ?)",
+            (model_id, field_name, field_type, 1 if is_pk else 0),
+        )
+
+    for rel in relationships:
+        conn.execute(
+            "INSERT INTO relationships (model_id, kind, target, field) VALUES (?, ?, ?, ?)",
+            (model_id, str(rel.get("kind", "")), str(rel.get("target", "")), str(rel.get("field", ""))),
+        )
+
+    return model_id
+
+
+def get_all_files(conn: sqlite3.Connection) -> list[Path]:
+    cur = conn.execute("SELECT path FROM files ORDER BY path")
+    return [Path(r[0]) for r in cur.fetchall()]
+
+
+def get_file_imports(conn: sqlite3.Connection, file_id: int) -> list[str]:
+    cur = conn.execute("SELECT import_path FROM imports WHERE file_id = ? ORDER BY id", (file_id,))
+    return [str(r[0]) for r in cur.fetchall()]
+
+
+def get_file_symbols(conn: sqlite3.Connection, file_id: int) -> list[dict]:
+    cur = conn.execute(
+        "SELECT name, type, line_number FROM symbols WHERE file_id = ? ORDER BY COALESCE(line_number, 1000000)",
+        (file_id,),
+    )
+    return [{"name": r[0], "type": r[1], "line": r[2]} for r in cur.fetchall()]
+
+
+def get_models(conn: sqlite3.Connection) -> list[dict]:
+    cur = conn.execute(
+        "SELECT m.id, m.name, f.path FROM models m JOIN files f ON m.file_id = f.id ORDER BY m.name"
+    )
+    out: list[dict] = []
+    for model_id, name, path in cur.fetchall():
+        fcur = conn.execute("SELECT name, type, is_primary_key FROM model_fields WHERE model_id = ?", (model_id,))
+        fields = [(r[0], r[1], bool(r[2])) for r in fcur.fetchall()]
+        out.append({"name": name, "path": Path(path), "fields": fields})
+    return out
+
+
+def needs_rescan(conn: sqlite3.Connection, project_root: Path) -> bool:
+    from ..scanner.scanner import find_all_supported_files
+
+    current_files = {str(p.resolve()) for p in find_all_supported_files(project_root)}
+    cur = conn.execute("SELECT path FROM files")
+    cached_files = {str(r[0]) for r in cur.fetchall()}
+    if current_files != cached_files:
+        return True
+
+    cur = conn.execute("SELECT path, modified_time FROM files")
+    for path_str, cached_mtime in cur.fetchall():
+        p = Path(path_str)
+        if not p.exists():
+            return True
+        now_mtime = get_file_modified_time(p)
+        if abs(float(now_mtime) - float(cached_mtime)) > 0.01:
+            return True
+
+    return False
+
+
+def get_imports_map_for_paths(conn: sqlite3.Connection, paths: list[Path]) -> dict[str, list[str]]:
+    if not paths:
+        return {}
+
+    path_strs = [str(p.resolve()) for p in paths]
+    CHUNK = 800
+    out: dict[str, list[str]] = {}
+
+    for i in range(0, len(path_strs), CHUNK):
+        chunk = path_strs[i : i + CHUNK]
+        placeholders = ",".join("?" for _ in chunk)
+        rows = conn.execute(
+            f"""
+            SELECT f.path, imp.import_path
+            FROM imports imp
+            JOIN files f ON f.id = imp.file_id
+            WHERE f.path IN ({placeholders})
+            ORDER BY imp.id
+            """,
+            chunk,
+        ).fetchall()
+
+        for pstr, imp in rows:
+            out.setdefault(str(pstr), []).append(str(imp))
+
+        for pstr in chunk:
+            out.setdefault(pstr, out.get(pstr, []))
+
+    return out
+
+
+def get_deps_map_for_paths(conn: sqlite3.Connection, paths: list[Path]) -> dict[str, list[str]]:
+    if not paths:
+        return {}
+
+    path_strs = [str(p.resolve()) for p in paths]
+    CHUNK = 600
+    out: dict[str, list[str]] = {}
+
+    for i in range(0, len(path_strs), CHUNK):
+        chunk = path_strs[i : i + CHUNK]
+        placeholders = ",".join("?" for _ in chunk)
+        rows = conn.execute(
+            f"""
+            SELECT f1.path, f2.path
+            FROM imports i
+            JOIN files f1 ON f1.id = i.file_id
+            JOIN files f2 ON f2.id = i.resolved_file_id
+            WHERE f1.path IN ({placeholders})
+            ORDER BY f1.path, f2.path
+            """,
+            chunk,
+        ).fetchall()
+
+        for src, dep in rows:
+            out.setdefault(str(src), []).append(str(dep))
+
+        for src in chunk:
+            out.setdefault(src, out.get(src, []))
+
+    return out
+
+
+def get_all_file_id_map(conn: sqlite3.Connection) -> dict[str, int]:
+    cur = conn.execute("SELECT id, path FROM files")
+    return {str(path): int(fid) for fid, path in cur.fetchall()}
+
+
+def get_unresolved_import_rows(conn: sqlite3.Connection) -> list[tuple[int, int, str]]:
+    cur = conn.execute(
+        "SELECT id, file_id, import_path FROM imports WHERE resolved_file_id IS NULL ORDER BY id"
+    )
+    return [(int(r[0]), int(r[1]), str(r[2])) for r in cur.fetchall()]
+
+
+def get_file_path_and_lang(conn: sqlite3.Connection, file_id: int) -> tuple[str, str] | None:
+    cur = conn.execute("SELECT path, language FROM files WHERE id = ?", (file_id,))
+    row = cur.fetchone()
+    if not row:
+        return None
+    return str(row[0]), str(row[1])
+
+
+def get_deps_for_path(conn: sqlite3.Connection, path: Path) -> list[Path]:
+    cur = conn.execute(
+        """
+        SELECT f2.path
+        FROM imports i
+        JOIN files f1 ON f1.id = i.file_id
+        JOIN files f2 ON f2.id = i.resolved_file_id
+        WHERE f1.path = ?
+        ORDER BY f2.path
+        """,
+        (str(path.resolve()),),
+    )
+    return [Path(r[0]) for r in cur.fetchall()]
+
+
+def get_model_by_file_path(conn: sqlite3.Connection, path: Path) -> tuple[int, str] | None:
+    cur = conn.execute(
+        """
+        SELECT m.id, m.name
+        FROM models m
+        JOIN files f ON f.id = m.file_id
+        WHERE f.path = ?
+        """,
+        (str(path.resolve()),),
+    )
+    row = cur.fetchone()
+    if not row:
+        return None
+    return int(row[0]), str(row[1])
+
+
+def get_model_fields(conn: sqlite3.Connection, model_id: int) -> list[tuple[str, str, bool]]:
+    cur = conn.execute(
+        "SELECT name, type, is_primary_key FROM model_fields WHERE model_id = ? ORDER BY id",
+        (model_id,),
+    )
+    return [(str(n), str(t), bool(pk)) for n, t, pk in cur.fetchall()]
+
+
+def get_model_relationships(conn: sqlite3.Connection, model_id: int) -> list[dict[str, str]]:
+    cur = conn.execute(
+        "SELECT kind, target, field FROM relationships WHERE model_id = ? ORDER BY id",
+        (model_id,),
+    )
+    return [{"kind": str(k), "target": str(t), "field": str(f)} for k, t, f in cur.fetchall()]
+
+
+def get_fields_by_model_names(conn: sqlite3.Connection, names: list[str]) -> dict[str, list[tuple[str, str, bool]]]:
+    if not names:
+        return {}
+    CHUNK = 400
+    out: dict[str, list[tuple[str, str, bool]]] = {}
+
+    for i in range(0, len(names), CHUNK):
+        chunk = names[i : i + CHUNK]
+        placeholders = ",".join("?" for _ in chunk)
+        rows = conn.execute(
+            f"""
+            SELECT m.name, mf.name, mf.type, mf.is_primary_key
+            FROM model_fields mf
+            JOIN models m ON m.id = mf.model_id
+            WHERE m.name IN ({placeholders})
+            ORDER BY m.name, mf.id
+            """,
+            chunk,
+        ).fetchall()
+
+        for mname, fname, ftype, pk in rows:
+            out.setdefault(str(mname), []).append((str(fname), str(ftype), bool(pk)))
+
+        for n in chunk:
+            out.setdefault(n, out.get(n, []))
+
+    return out
+
+
+def get_reverse_relationships(conn: sqlite3.Connection, target_model_name: str) -> list[dict[str, str]]:
+    cur = conn.execute(
+        """
+        SELECT m.name, r.kind, r.field
+        FROM relationships r
+        JOIN models m ON m.id = r.model_id
+        WHERE r.target = ?
+        ORDER BY m.name, r.kind, r.field
+        """,
+        (target_model_name,),
+    )
+    return [{"source": str(src), "kind": str(kind), "field": str(field)} for src, kind, field in cur.fetchall()]

codeintel_cli/db/schema.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+import sqlite3
+from pathlib import Path
+from datetime import datetime
+
+SCHEMA_VERSION = 2
+
+SCHEMA_SQL = """
+CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS files (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT UNIQUE NOT NULL,
+    rel_path TEXT NOT NULL,
+    language TEXT NOT NULL,
+    modified_time REAL NOT NULL,
+    scanned_at REAL NOT NULL,
+    content_hash TEXT
+);
+
+CREATE TABLE IF NOT EXISTS imports (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id INTEGER NOT NULL,
+    import_path TEXT NOT NULL,
+    import_level INTEGER NOT NULL DEFAULT 0,
+    resolved_file_id INTEGER,
+    FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE,
+    FOREIGN KEY (resolved_file_id) REFERENCES files(id) ON DELETE SET NULL
+);
+
+CREATE TABLE IF NOT EXISTS symbols (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL,
+    line_number INTEGER,
+    FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS models (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS model_fields (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    model_id INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL,
+    is_primary_key INTEGER DEFAULT 0,
+    FOREIGN KEY (model_id) REFERENCES models(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS relationships (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    model_id INTEGER NOT NULL,
+    kind TEXT NOT NULL,
+    target TEXT NOT NULL,
+    field TEXT NOT NULL,
+    FOREIGN KEY (model_id) REFERENCES models(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_files_path ON files(path);
+CREATE INDEX IF NOT EXISTS idx_files_rel_path ON files(rel_path);
+CREATE INDEX IF NOT EXISTS idx_files_language ON files(language);
+CREATE INDEX IF NOT EXISTS idx_imports_file_id ON imports(file_id);
+CREATE INDEX IF NOT EXISTS idx_imports_resolved ON imports(resolved_file_id);
+CREATE INDEX IF NOT EXISTS idx_symbols_file_id ON symbols(file_id);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+CREATE INDEX IF NOT EXISTS idx_models_file_id ON models(file_id);
+CREATE INDEX IF NOT EXISTS idx_model_fields_model_id ON model_fields(model_id);
+CREATE INDEX IF NOT EXISTS idx_relationships_model_id ON relationships(model_id);
+"""
+
+def init_db(db_path: Path) -> sqlite3.Connection:
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(db_path))
+
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA synchronous = NORMAL")
+    conn.execute("PRAGMA temp_store = MEMORY")
+    conn.execute("PRAGMA cache_size = -20000")
+    conn.execute("PRAGMA busy_timeout = 3000")
+
+    conn.executescript(SCHEMA_SQL)
+
+    row = conn.execute("SELECT value FROM metadata WHERE key = 'schema_version'").fetchone()
+    if row is None:
+        conn.execute("INSERT INTO metadata (key, value) VALUES ('schema_version', ?)", (str(SCHEMA_VERSION),))
+        conn.execute("INSERT INTO metadata (key, value) VALUES ('created_at', ?)", (datetime.now().isoformat(),))
+        conn.commit()
+
+    return conn
+
+def get_db_path(project_root: Path) -> Path:
+    return project_root / ".codeintel" / "index.db"

codeintel_cli/errors.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class CodeIntelError(Exception):
+    """
+    Base exception for all expected (user-facing) errors.
+    The CLI catches these and prints clean messages.
+    """
+    message: str
+    hint: Optional[str] = None
+    exit_code: int = 1
+
+    def __str__(self) -> str:
+        if self.hint:
+            return f"{self.message}\nHint: {self.hint}"
+        return self.message
+
+
+@dataclass
+class InvalidPathError(CodeIntelError):
+    path: Path = Path(".")
+    exit_code: int = 2
+
+    def __post_init__(self) -> None:
+        if not self.message:
+            self.message = f"Path must be an existing folder: {self.path}"
+            self.hint = "Pass a directory path like '.' or 'src/'."
+
+
+@dataclass
+class PermissionDeniedError(CodeIntelError):
+    path: Path = Path(".")
+    exit_code: int = 3
+
+    def __post_init__(self) -> None:
+        if not self.message:
+            self.message = f"Permission denied while reading: {self.path}"
+            self.hint = "Check folder permissions or run terminal with appropriate access."
+
+
+@dataclass
+class ScanFailedError(CodeIntelError):
+    root: Path = Path(".")
+    exit_code: int = 4
+
+    def __post_init__(self) -> None:
+        if not self.message:
+            self.message = f"Scan failed under: {self.root}"
+            self.hint = "Try scanning a smaller folder or enable --verbose for details."
+
+
+@dataclass
+class NoPythonFilesFoundError(CodeIntelError):
+    root: Path = Path(".")
+    exit_code: int = 5
+
+    def __post_init__(self) -> None:
+        if not self.message:
+            self.message = f"No Python files found under: {self.root}"
+            self.hint = "Confirm you are scanning the correct folder."
+
+
+def wrap_unexpected_error(err: Exception, context: str = "") -> CodeIntelError:
+    """
+    Convert unknown exceptions into a user-facing CodeIntelError.
+    Use in CLI as a last-resort catch.
+    """
+    prefix = f"{context}: " if context else ""
+    return CodeIntelError(
+        message=f"{prefix}{err.__class__.__name__}: {err}",
+        hint="Re-run with --verbose. If it persists, share the command + folder path.",
+        exit_code=1,
+    )

codeintel_cli/graph/__init__.py

@@ -0,0 +1 @@
+__all__ = []

codeintel_cli/graph/builder.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+
+from ..lang.router import extract_imports
+from ..lang.java.resolve import resolve_java_import_to_file
+from ..parser.resolve import resolve_import_to_file
+from ..core.where import file_to_module
+from ..db.cache import CacheManager
+from ..db.operations import get_deps_map_for_paths
+
+def _is_under_root(path: Path, root: Path) -> bool:
+    try:
+        path = path.resolve()
+        root = root.resolve()
+    except Exception:
+        return False
+    try:
+        path.relative_to(root)
+        return True
+    except Exception:
+        return False
+
+def _is_stdlib_module(module: str) -> bool:
+    if not module:
+        return False
+    top = module.split(".", 1)[0]
+    stdlib_names = getattr(sys, "stdlib_module_names", None)
+    if stdlib_names and top in stdlib_names:
+        return True
+    if top in {"__future__", "builtins"}:
+        return True
+    return False
+
+def _detect_lang(path: Path) -> str:
+    return "java" if path.suffix == ".java" else "python"
+
+def build_graph(files: list[Path], root: Path) -> dict[Path, set[Path]]:
+    graph, _ = build_graph_with_counts(files, root)
+    return graph
+
+def build_graph_with_counts(
+    files: list[Path],
+    root: Path,
+    *,
+    ignore_stdlib: bool = True,
+    ignore_outside_root: bool = True,
+    use_sqlite_cache: bool = False,
+) -> tuple[dict[Path, set[Path]], dict[Path, int]]:
+    root = root.resolve()
+    graph: dict[Path, set[Path]] = {}
+    dependents_count: dict[Path, int] = {}
+
+    java_map: dict[str, Path] = {}
+    for f0 in files:
+        f0r = f0.resolve()
+        if f0r.suffix.lower() == ".java":
+            m = file_to_module(f0r, root)
+            if m:
+                java_map[m] = f0r
+
+    cached_deps_by_path: dict[str, list[str]] | None = None
+    if use_sqlite_cache:
+        try:
+            with CacheManager(root) as cache:
+                if cache.needs_rescan():
+                    cache.scan_project(verbose=False)
+                cached_deps_by_path = get_deps_map_for_paths(cache.conn, files) if cache.conn else None
+        except Exception:
+            cached_deps_by_path = None
+
+    for f in files:
+        f = f.resolve()
+        lang = _detect_lang(f)
+
+        deps: set[Path] = set()
+
+        if cached_deps_by_path is not None:
+            for dst in cached_deps_by_path.get(str(f), []):
+                t = Path(dst)
+                try:
+                    t = t.resolve()
+                except Exception:
+                    continue
+                if ignore_outside_root and not _is_under_root(t, root):
+                    continue
+                if t == f:
+                    continue
+                if t not in deps:
+                    deps.add(t)
+                    dependents_count[t] = dependents_count.get(t, 0) + 1
+
+            graph[f] = deps
+            continue
+
+        try:
+            imports = extract_imports(f, lang)
+        except Exception:
+            imports = []
+
+        for item in imports:
+            if isinstance(item, tuple):
+                mod, level = item
+            else:
+                mod, level = str(item), 0
+
+            if lang == "python":
+                if ignore_stdlib and _is_stdlib_module(mod):
+                    continue
+                target = resolve_import_to_file(mod, level, f, root)
+            else:
+                if not mod or mod.endswith(".*"):
+                    continue
+                target = resolve_java_import_to_file(mod, root)
+                if not target:
+                    target = java_map.get(mod)
+
+            if not target:
+                continue
+
+            try:
+                target = target.resolve()
+            except Exception:
+                continue
+
+            if ignore_outside_root and not _is_under_root(target, root):
+                continue
+
+            if target == f:
+                continue
+
+            if target not in deps:
+                deps.add(target)
+                dependents_count[target] = dependents_count.get(target, 0) + 1
+
+        graph[f] = deps
+
+    return graph, dependents_count
+
+def get_hub_files_by_ratio(
+    dependents_count: dict[Path, int],
+    total_files: int,
+    ratio: float,
+) -> set[Path]:
+    if total_files <= 0 or ratio <= 0:
+        return set()
+    limit = total_files * ratio
+    return {p for p, c in dependents_count.items() if c > limit}

codeintel_cli/graph/query.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from pathlib import Path
+
+from .traverse import build_reverse_graph, bfs_related
+
+
+def get_direct_deps(graph: dict[Path, set[Path]], file: Path) -> set[Path]:
+    return graph.get(file, set())
+
+
+def get_reverse_deps(graph: dict[Path, set[Path]], file: Path) -> set[Path]:
+    rev = build_reverse_graph(graph)
+    return rev.get(file, set())
+
+
+def get_related(
+    graph: dict[Path, set[Path]],
+    file: Path,
+    depth: int,
+    include_reverse: bool = True,
+    hubs: set[Path] | None = None,
+) -> set[Path]:
+    out = set()
+    out |= bfs_related(graph, file, depth, skip=hubs)
+
+    if include_reverse:
+        rev = build_reverse_graph(graph)
+        out |= bfs_related(rev, file, depth, skip=hubs)
+
+    return out