aja-codeintel 0.1.0__py3-none-any.whl

codeintel_cli/commands/graph/related_cmd.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from collections import deque
+from pathlib import Path
+import typer
+
+from ...graph.builder import build_graph_with_counts, get_hub_files_by_ratio
+from ...core.resolve_target import resolve_target_file
+from ...db.cache import CacheManager
+
+
+def _layered_related(
+    graph: dict[Path, set[Path]],
+    start: Path,
+    depth: int,
+    include_reverse: bool,
+    hubs: set[Path],
+) -> list[list[Path]]:
+    adj: dict[Path, set[Path]] = {k: set(v) for k, v in graph.items()}
+
+    if include_reverse:
+        rev: dict[Path, set[Path]] = {}
+        for src, deps in adj.items():
+            for dst in deps:
+                rev.setdefault(dst, set()).add(src)
+        for node, incoming in rev.items():
+            adj.setdefault(node, set()).update(incoming)
+
+    layers: list[list[Path]] = []
+    visited: set[Path] = {start}
+    q: deque[tuple[Path, int]] = deque([(start, 0)])
+    by_depth: dict[int, list[Path]] = {}
+
+    while q:
+        node, d = q.popleft()
+        if d == depth:
+            continue
+
+        for nxt in adj.get(node, set()):
+            if nxt in visited:
+                continue
+            if nxt in hubs:
+                continue
+            visited.add(nxt)
+            nd = d + 1
+            by_depth.setdefault(nd, []).append(nxt)
+            q.append((nxt, nd))
+
+    for d in range(1, depth + 1):
+        items = sorted(by_depth.get(d, []))
+        layers.append(items)
+
+    return layers
+
+
+def register_related(app: typer.Typer) -> None:
+    @app.command(help="Show related files using depth traversal (layered).")
+    def related(
+        file: str = typer.Argument(...),
+        root: str = typer.Argument("."),
+        depth: int = typer.Option(2, "--depth", "-d"),
+        forward_only: bool = typer.Option(False, "--forward-only"),
+        include_hubs: bool = typer.Option(False, "--include-hubs"),
+        use_sqlite_cache: bool = typer.Option(True, "--use-sqlite-cache/--no-sqlite-cache"),
+    ):
+        target, root_path = resolve_target_file(file, root=root)
+
+        if use_sqlite_cache:
+            with CacheManager(root_path) as cache:
+                if cache.needs_rescan():
+                    cache.scan_project(verbose=False)
+                files = cache.get_cached_files()
+        else:
+            files = []
+            for p in root_path.rglob("*"):
+                if p.is_file() and p.suffix.lower() in {".py", ".java"}:
+                    files.append(p.resolve())
+            files = sorted(set(files))
+
+        graph, dependents_count = build_graph_with_counts(
+            files,
+            root_path,
+            use_sqlite_cache=use_sqlite_cache,
+        )
+
+        hubs: set[Path] = set()
+        if not include_hubs:
+            hubs = get_hub_files_by_ratio(dependents_count, len(files), 0.5)
+
+        layers = _layered_related(
+            graph=graph,
+            start=target,
+            depth=depth,
+            include_reverse=not forward_only,
+            hubs=hubs,
+        )
+
+        total = sum(len(x) for x in layers)
+        if total == 0:
+            typer.echo("No related files.")
+            raise typer.Exit(0)
+
+        typer.echo(f"TARGET: {target.relative_to(root_path)}")
+        typer.echo(f"DEPTH: {depth} ({'forward-only' if forward_only else 'forward+reverse'})")
+        typer.echo(f"FILES: {total}")
+        typer.echo("")
+
+        for i, items in enumerate(layers, 1):
+            typer.echo(f"LEVEL {i} ({len(items)})")
+            if not items:
+                typer.echo("  (none)")
+                typer.echo("")
+                continue
+
+            for p in items:
+                try:
+                    typer.echo(f"  {p.relative_to(root_path)}")
+                except Exception:
+                    typer.echo(f"  {p}")
+
+            typer.echo("")

codeintel_cli/commands/graph/relsymbols_cmd.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+from collections import deque
+from pathlib import Path
+import re
+import typer
+
+from ...graph.builder import build_graph_with_counts, get_hub_files_by_ratio
+from ...parser.symbols import extract_classes_from_file, extract_funcs_from_file
+from ...core.resolve_target import resolve_target_file
+from ...db.cache import CacheManager
+
+
+_JAVA_TYPE_RE = re.compile(r"\b(class|interface|enum|record)\s+([A-Za-z_][A-Za-z0-9_]*)\b")
+_JAVA_METHOD_RE = re.compile(
+    r"^\s*(?:@\w+(?:\([^)]*\))?\s*)*(?:public|protected|private)\s+(?:static\s+)?"
+    r"(?:final\s+)?([A-Za-z0-9_<>\[\].,?]+)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*"
+)
+
+
+def _detect_lang(p: Path) -> str:
+    return "java" if p.suffix.lower() == ".java" else "python"
+
+
+def _short_path(p: Path, root: Path) -> str:
+    try:
+        return str(p.relative_to(root))
+    except Exception:
+        return str(p)
+
+
+def _java_types(path: Path) -> dict[str, list[str]]:
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return {"class": [], "interface": [], "enum": [], "record": []}
+
+    out: dict[str, list[str]] = {"class": [], "interface": [], "enum": [], "record": []}
+    seen: set[str] = set()
+
+    for line in text.splitlines():
+        m = _JAVA_TYPE_RE.search(line)
+        if not m:
+            continue
+        kind = m.group(1)
+        name = m.group(2)
+        key = f"{kind}:{name}"
+        if key in seen:
+            continue
+        seen.add(key)
+        out.setdefault(kind, []).append(name)
+
+    return out
+
+
+def _java_methods(path: Path) -> list[str]:
+    try:
+        lines = path.read_text(encoding="utf-8", errors="ignore").splitlines()
+    except Exception:
+        return []
+
+    out: list[str] = []
+    seen: set[str] = set()
+
+    for line in lines:
+        s = line.strip()
+        if not s:
+            continue
+        if s.startswith(("class ", "interface ", "record ", "enum ")):
+            continue
+        m = _JAVA_METHOD_RE.match(line)
+        if not m:
+            continue
+        ret = m.group(1).strip()
+        name = m.group(2).strip()
+        args = m.group(3).strip()
+        sig = f"{name}({args}) → {ret}"
+        if sig not in seen:
+            seen.add(sig)
+            out.append(sig)
+
+    return out
+
+
+def _py_symbols(path: Path) -> tuple[list[str], list[str]]:
+    classes: list[str] = []
+    funcs: list[str] = []
+
+    for c in extract_classes_from_file(path):
+        if not c.name.startswith("_"):
+            classes.append(c.name)
+
+    for fn in extract_funcs_from_file(path):
+        if fn.name.startswith("_") or fn.name.startswith("register_"):
+            continue
+        funcs.append(fn.signature)
+
+    return classes, funcs
+
+
+def _build_layers(
+    graph: dict[Path, set[Path]],
+    start: Path,
+    depth: int,
+    *,
+    include_reverse: bool,
+    hubs: set[Path],
+) -> dict[int, list[Path]]:
+    adj: dict[Path, set[Path]] = {k: set(v) for k, v in graph.items()}
+
+    if include_reverse:
+        rev: dict[Path, set[Path]] = {}
+        for src, deps in adj.items():
+            for dst in deps:
+                rev.setdefault(dst, set()).add(src)
+        for node, incoming in rev.items():
+            adj.setdefault(node, set()).update(incoming)
+
+    visited: set[Path] = {start}
+    q: deque[tuple[Path, int]] = deque([(start, 0)])
+    by_depth: dict[int, list[Path]] = {}
+
+    while q:
+        node, d = q.popleft()
+        if d >= depth:
+            continue
+
+        for nxt in adj.get(node, set()):
+            if nxt in visited:
+                continue
+            if hubs and nxt in hubs:
+                continue
+            visited.add(nxt)
+            nd = d + 1
+            by_depth.setdefault(nd, []).append(nxt)
+            q.append((nxt, nd))
+
+    for k in list(by_depth.keys()):
+        by_depth[k] = sorted(set(by_depth[k]))
+
+    return by_depth
+
+
+def _print_java_target(path: Path, root: Path, *, all: bool) -> None:
+    typer.echo(f"TARGET: {_short_path(path, root)}")
+    typer.echo("")
+
+    types_map = _java_types(path)
+    methods = _java_methods(path)
+
+    if types_map["interface"]:
+        typer.echo("INTERFACES")
+        for n in types_map["interface"]:
+            typer.echo(f"  {n}")
+        typer.echo("")
+
+    if all:
+        if types_map["class"]:
+            typer.echo("CLASSES")
+            for n in types_map["class"]:
+                typer.echo(f"  {n}")
+            typer.echo("")
+
+        if types_map["record"]:
+            typer.echo("RECORDS")
+            for n in types_map["record"]:
+                typer.echo(f"  {n}")
+            typer.echo("")
+
+        if types_map["enum"]:
+            typer.echo("ENUMS")
+            for n in types_map["enum"]:
+                typer.echo(f"  {n}")
+            typer.echo("")
+
+        if methods:
+            typer.echo("METHODS")
+            for m in methods:
+                typer.echo(f"  {m}")
+            typer.echo("")
+
+    if not types_map["interface"] and not (
+        all and (types_map["class"] or types_map["enum"] or types_map["record"] or methods)
+    ):
+        typer.echo("(no symbols)")
+        typer.echo("")
+
+
+def _print_python_target(path: Path, root: Path) -> None:
+    typer.echo(f"TARGET: {_short_path(path, root)}")
+    typer.echo("")
+
+    classes, funcs = _py_symbols(path)
+
+    if classes:
+        typer.echo("CLASSES")
+        for c in classes:
+            typer.echo(f"  {c}")
+        typer.echo("")
+
+    if funcs:
+        typer.echo("FUNCTIONS")
+        for f in funcs:
+            typer.echo(f"  {f}")
+        typer.echo("")
+
+    if not classes and not funcs:
+        typer.echo("(no symbols)")
+        typer.echo("")
+
+
+def _print_java_related(path: Path, root: Path, *, all: bool) -> None:
+    typer.echo(_short_path(path, root))
+
+    types_map = _java_types(path)
+
+    if types_map["interface"]:
+        typer.echo("  INTERFACES")
+        for n in types_map["interface"]:
+            typer.echo(f"    {n}")
+
+    if all:
+        if types_map["class"]:
+            typer.echo("  CLASSES")
+            for n in types_map["class"]:
+                typer.echo(f"    {n}")
+
+        if types_map["record"]:
+            typer.echo("  RECORDS")
+            for n in types_map["record"]:
+                typer.echo(f"    {n}")
+
+        if types_map["enum"]:
+            typer.echo("  ENUMS")
+            for n in types_map["enum"]:
+                typer.echo(f"    {n}")
+
+        methods = _java_methods(path)
+        if methods:
+            typer.echo("  METHODS")
+            for m in methods:
+                typer.echo(f"    {m}")
+
+    typer.echo("")
+
+
+def _print_python_related(path: Path, root: Path) -> None:
+    typer.echo(_short_path(path, root))
+
+    classes, funcs = _py_symbols(path)
+
+    if classes:
+        typer.echo("  CLASSES")
+        for c in classes:
+            typer.echo(f"    {c}")
+
+    if funcs:
+        typer.echo("  FUNCTIONS")
+        for f in funcs:
+            typer.echo(f"    {f}")
+
+    typer.echo("")
+
+
+def register_relsymbols(app: typer.Typer) -> None:
+    @app.command(help="Show related classes/functions/interfaces")
+    def relsymbols(
+        file: str = typer.Argument(...),
+        root: str = typer.Argument("."),
+        depth: int = typer.Option(1, "--depth", "-d"),
+        forward_only: bool = typer.Option(False, "--forward-only"),
+        include_hubs: bool = typer.Option(False, "--include-hubs"),
+        all: bool = typer.Option(False, "--all", help="Show all symbols (Java: classes+methods, Python: unchanged)"),
+        use_sqlite_cache: bool = typer.Option(True, "--use-sqlite-cache/--no-sqlite-cache"),
+    ):
+        target, root_path = resolve_target_file(file, root=root)
+
+        if use_sqlite_cache:
+            with CacheManager(root_path) as cache:
+                if cache.needs_rescan():
+                    cache.scan_project(verbose=False)
+                files = cache.get_cached_files()
+        else:
+            files = []
+            for p in root_path.rglob("*"):
+                if p.is_file() and p.suffix.lower() in {".py", ".java"}:
+                    files.append(p.resolve())
+            files = sorted(set(files))
+
+        graph, dependents_count = build_graph_with_counts(
+            files,
+            root_path,
+            use_sqlite_cache=use_sqlite_cache,
+        )
+
+        hubs: set[Path] = set()
+        if not include_hubs:
+            hubs = get_hub_files_by_ratio(dependents_count, len(files), 0.5)
+
+        depth = max(1, depth)
+
+        layers = _build_layers(
+            graph=graph,
+            start=target,
+            depth=depth,
+            include_reverse=not forward_only,
+            hubs=hubs,
+        )
+
+        lang = _detect_lang(target)
+        if lang == "java":
+            _print_java_target(target, root_path, all=all)
+        else:
+            _print_python_target(target, root_path)
+
+        printed_any = False
+
+        for lvl in sorted(layers.keys()):
+            items = layers[lvl]
+            if not items:
+                continue
+
+            printed_any = True
+            typer.echo(f"LEVEL {lvl}")
+            typer.echo("")
+
+            for item_path in items:
+                if item_path.name == "__init__.py":
+                    continue
+
+                item_lang = _detect_lang(item_path)
+
+                if item_lang == "java":
+                    types_map = _java_types(item_path)
+                    if not types_map["interface"] and not (
+                        all and (types_map["class"] or types_map["enum"] or types_map["record"])
+                    ):
+                        continue
+                    _print_java_related(item_path, root_path, all=all)
+                else:
+                    classes, funcs = _py_symbols(item_path)
+                    if not classes and not funcs:
+                        continue
+                    _print_python_related(item_path, root_path)
+
+        if not printed_any:
+            typer.echo("(no related symbols)")

codeintel_cli/commands/graph/reverse_related_cmd.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import typer
+
+from ...graph.builder import build_graph_with_counts, get_hub_files_by_ratio
+from ...graph.traverse import build_reverse_graph, bfs_related
+from ...core.resolve_target import resolve_target_file
+from ...db.cache import CacheManager
+
+
+def register_rrelated(app: typer.Typer) -> None:
+    @app.command(help="Show reverse-related files (who depends on this) using depth traversal.")
+    def rrelated(
+        file: str = typer.Argument(..., help="Target source file (path or filename)"),
+        depth: int = typer.Option(2, "--depth", "-d", help="Traversal depth"),
+        include_hubs: bool = typer.Option(False, "--include-hubs"),
+        use_sqlite_cache: bool = typer.Option(True, "--use-sqlite-cache/--no-sqlite-cache"),
+    ):
+        target_file, root_path = resolve_target_file(file)
+
+        if use_sqlite_cache:
+            with CacheManager(root_path) as cache:
+                if cache.needs_rescan():
+                    cache.scan_project(verbose=False)
+                files = cache.get_cached_files()
+        else:
+            files = []
+            for p in root_path.rglob("*"):
+                if p.is_file() and p.suffix.lower() in {".py", ".java"}:
+                    files.append(p.resolve())
+            files = sorted(set(files))
+
+        graph, dependents_count = build_graph_with_counts(
+            files,
+            root_path,
+            use_sqlite_cache=use_sqlite_cache,
+        )
+
+        hubs: set = set()
+        if not include_hubs:
+            hubs = get_hub_files_by_ratio(dependents_count, len(files), 0.5)
+
+        rev = build_reverse_graph(graph)
+        rel = bfs_related(rev, target_file, depth, skip=hubs)
+
+        if not rel:
+            typer.echo("No reverse-related files.")
+            raise typer.Exit(0)
+
+        for p in sorted(rel):
+            try:
+                typer.echo(str(p.relative_to(root_path)))
+            except Exception:
+                typer.echo(str(p))

codeintel_cli/commands/nav/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+import typer
+
+from .copy_cmd import register_copy
+from .open_cmd import register_open
+from .where_cmd import register_where
+
+
+def register_nav_commands(app: typer.Typer) -> None:
+    register_copy(app)
+    register_open(app)
+    register_where(app)

codeintel_cli/commands/nav/copy_cmd.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+from pathlib import Path
+import typer
+
+from ...core.resolve_target import resolve_target_file
+from ...core.project import find_project_root
+
+
+def _format_for_ai(files_content: list[tuple[Path, str]], root: Path) -> str:
+    lines: list[str] = []
+    
+    lines.append("=" * 80)
+    lines.append(f"COPIED {len(files_content)} FILE(S)")
+    lines.append("=" * 80)
+    lines.append("")
+    
+    for i, (path, content) in enumerate(files_content, 1):
+        try:
+            rel_path = path.relative_to(root)
+        except Exception:
+            rel_path = path
+        
+        file_name = path.name
+        full_path = rel_path.as_posix()
+        lang = "java" if path.suffix == ".java" else "python"
+        line_count = content.count("\n") + 1
+        
+        lines.append("=" * 80)
+        lines.append(f"FILE {i}/{len(files_content)}: {file_name}")
+        lines.append(f"Path: {full_path}")
+        lines.append(f"Lines: {line_count}")
+        lines.append("=" * 80)
+        lines.append("")
+        lines.append(f"```{lang}")
+        lines.append(content.rstrip())
+        lines.append("```")
+        lines.append("")
+    
+    return "\n".join(lines)
+
+
+def register_copy(app: typer.Typer) -> None:
+    @app.command(help="Copy file(s) contents to clipboard")
+    def copy(
+        files: list[str] = typer.Argument(..., help="File(s) to copy"),
+        root: str = typer.Option(".", "--root", "-r"),
+        raw: bool = typer.Option(False, "--raw", help="Raw content without formatting"),
+    ) -> None:
+        try:
+            import pyperclip
+        except ImportError:
+            typer.echo("Error: pyperclip not installed")
+            typer.echo("Install: pip install pyperclip")
+            raise typer.Exit(1)
+
+        root_path = Path(root).resolve()
+        project_root = find_project_root(root_path)
+        
+        files_content: list[tuple[Path, str]] = []
+        total_lines = 0
+        total_chars = 0
+
+        for file_query in files:
+            try:
+                target, _ = resolve_target_file(file_query, root=str(project_root))
+            except Exception as e:
+                typer.echo(f"✗ Could not find: {file_query}")
+                continue
+
+            try:
+                content = target.read_text(encoding="utf-8", errors="ignore")
+            except Exception as e:
+                typer.echo(f"✗ Error reading {target.name}: {e}")
+                continue
+
+            files_content.append((target, content))
+            total_lines += content.count("\n") + 1
+            total_chars += len(content)
+
+        if not files_content:
+            typer.echo("✗ No files copied")
+            raise typer.Exit(1)
+
+        if raw:
+            combined = "\n\n".join(content for _, content in files_content)
+        else:
+            combined = _format_for_ai(files_content, project_root)
+
+        try:
+            pyperclip.copy(combined)
+        except Exception as e:
+            typer.echo(f"✗ Error copying to clipboard: {e}")
+            raise typer.Exit(1)
+
+        typer.echo(f"✓ Copied {len(files_content)} file(s) to clipboard")
+        typer.echo("")
+        for path, content in files_content:
+            lines = content.count("\n") + 1
+            typer.echo(f"  • {path.name} ({lines:,} lines)")
+        typer.echo("")
+        typer.echo(f"Total: {total_lines:,} lines, {total_chars:,} characters")

codeintel_cli/commands/nav/open_cmd.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import typer
+
+from ...core.opener import open_file
+from ...core.resolve_target import resolve_target_file
+
+
+def register_open(app: typer.Typer) -> None:
+    @app.command(help="Open a file by name or partial path (project-local).")
+    def open(
+        query: str = typer.Argument(..., help="Example: 'imports.py' or 'parser/imports.py'"),
+        yes: bool = typer.Option(False, "--yes", "-y", help="Open without confirmation"),
+    ):
+        target, _root = resolve_target_file(query)
+
+        if yes or typer.confirm(f"Open this file?\n{target}"):
+            open_file(target)

codeintel_cli/commands/nav/where_cmd.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import typer
+
+from ...errors import InvalidPathError
+from ...core.where import file_to_module
+from ...core.resolve_target import resolve_target_file
+
+
+def register_where(app: typer.Typer) -> None:
+    @app.command(help="Convert file path (or filename) to import path.")
+    def where(
+        file: str = typer.Argument(..., help="File path OR filename like 'imports.py' or 'UserService.java'"),
+    ):
+        target, root_path = resolve_target_file(file)
+
+        mod = file_to_module(target, root_path)
+        if not mod:
+            raise InvalidPathError(message="Cannot convert to module path", path=target)
+
+        typer.echo(mod)

codeintel_cli/commands/project/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+import typer
+
+from .scan_cmd import register_scan
+from .imports_cmd import register_imports
+from .version_cmd import register_version
+from .resolve_cmd import register_resolve
+from .context_cmd import register_context
+from .folder_cmd import register_folder
+from .tree_cmd import register_tree
+from .modeltree_cmd import register_modeltree
+from .models_cmd import register_models
+from .servicemap_cmd import register_servicemap
+
+
+def register_project_commands(app: typer.Typer) -> None:
+    register_scan(app)
+    register_imports(app)
+    register_version(app)
+    register_resolve(app)
+    register_context(app)
+    register_folder(app)
+    register_tree(app)
+    register_modeltree(app)
+    register_models(app)
+    register_servicemap(app)