aja-codeintel 0.1.0__py3-none-any.whl

codeintel_cli/commands/project/servicemap_cmd.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+from pathlib import Path
+import typer
+
+from ...errors import InvalidPathError
+from ...core.project import find_project_root
+from ...core.fuzzy import rank_paths, fuzzy_is_confident
+from ...context.java_service import analyze_java_service
+from ...context.python_service import analyze_python_service
+from ...db.cache import CacheManager
+
+PYTHON_SERVICE_DIRS = {"service", "services", "api", "views", "routes"}
+
+ANALYZERS = {
+    ".java": analyze_java_service,
+    ".py": analyze_python_service,
+}
+
+
+def _is_excluded_java_service_path(path: Path) -> bool:
+    parts = {p.lower() for p in path.parts}
+    stem = path.stem.lower()
+    name = path.name.lower()
+
+    if name == "package-info.java":
+        return True
+    if "dto" in parts or "mapper" in parts or "vm" in parts:
+        return True
+    if stem.endswith("dto") or "dto" in stem:
+        return True
+    if stem.endswith("mapper") or "mapper" in stem:
+        return True
+    return False
+
+
+def _java_has_service_annotation(path: Path) -> bool:
+    try:
+        txt = path.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return False
+    return "@Service" in txt
+
+
+def _is_service_file(path: Path) -> bool:
+    suffix = path.suffix.lower()
+    stem_lower = path.stem.lower()
+
+    if suffix == ".java":
+        if _is_excluded_java_service_path(path):
+            return False
+        if stem_lower.endswith("service"):
+            return True
+        return _java_has_service_annotation(path)
+
+    if suffix == ".py":
+        parts = {p.lower() for p in path.parts}
+        return bool(parts & PYTHON_SERVICE_DIRS)
+
+    return False
+
+
+def _short_rel(path: Path, root: Path, keep: int = 5) -> str:
+    try:
+        parts = list(path.relative_to(root).parts)
+    except ValueError:
+        return str(path)
+    tail = parts[-keep:] if len(parts) > keep else parts
+    return "/".join(tail)
+
+
+def _resolve_service_file(query: str, root: str = ".", top: int = 6) -> tuple[Path, Path]:
+    root_path = Path(root).resolve()
+    project_root = find_project_root(root_path)
+
+    direct = Path(query)
+    if direct.is_file():
+        return direct.resolve(), project_root
+
+    with CacheManager(project_root) as cache:
+        if cache.needs_rescan():
+            cache.scan_project(verbose=False)
+        all_files = cache.get_cached_files()
+
+    service_files = [p for p in all_files if _is_service_file(p)]
+    if not service_files:
+        raise InvalidPathError(message="No service files found", path=project_root)
+
+    query_stem = Path(query).stem.lower()
+    exact = [f for f in service_files if f.stem.lower() == query_stem]
+    if len(exact) == 1:
+        return exact[0].resolve(), project_root
+
+    ranked = rank_paths(query, service_files, project_root, top=top)
+    if not ranked:
+        raise InvalidPathError(message="Service not found", path=Path(query))
+
+    if fuzzy_is_confident(ranked):
+        top_score = ranked[0][1]
+        if sum(1 for _, s in ranked if abs(s - top_score) < 0.01) == 1:
+            return ranked[0][0].resolve(), project_root
+
+    typer.echo("Multiple matches found — select a service:")
+    for i, (p, score) in enumerate(ranked, 1):
+        typer.echo(f"  {i}. {_short_rel(p, project_root)}  (score={score:.2f})")
+
+    choice = typer.prompt("Enter number (0 to cancel)", type=int, default=0)
+    if not (1 <= choice <= len(ranked)):
+        raise typer.Exit()
+
+    return ranked[choice - 1][0].resolve(), project_root
+
+
+def _render_service_map(data: dict) -> list[str]:
+    lines: list[str] = [data["service_name"], "━" * 80, ""]
+
+    if endpoints := data.get("endpoints", []):
+        lines.append("ENDPOINTS")
+        for ep in endpoints:
+            lines.append(f"  {ep.get('method', '').ljust(7)} {ep.get('path', '')}")
+            if handler := ep.get("handler"):
+                lines.append(f"           → {handler}")
+        lines.append("")
+
+    if methods := data.get("methods", []):
+        lines.append("SERVICE METHODS")
+        for m in methods:
+            sig = f"{m.get('name', '')}({m.get('params', '')})"
+            if ret := m.get("return"):
+                sig += f" → {ret}"
+            lines.append(f"  • {sig}")
+        lines.append("")
+
+    if models := data.get("models", {}):
+        lines.append("MODELS")
+        for model_name, model_data in models.items():
+            lines.append(f"  {model_name}")
+            for fname, ftype, is_pk in model_data.get("fields", []):
+                marker = "🔑" if is_pk else "  "
+                lines.append(f"    {marker} {fname}: {ftype}")
+            for rel in model_data.get("relationships", []):
+                lines.append(f"      → {rel.get('kind', '')} {rel.get('target', '')} (via {rel.get('field', '')})")
+        lines.append("")
+
+    if repos := data.get("repositories", []):
+        lines.append("REPOSITORIES")
+        for repo in repos:
+            lines.append(f"  {repo.get('name', '')}")
+            for method in repo.get("methods", [])[:3]:
+                lines.append(f"    • {method}")
+        lines.append("")
+
+    if summary := data.get("summary", {}):
+        lines.append("SUMMARY")
+        lines.extend(f"  {k}: {v}" for k, v in summary.items())
+
+    return lines
+
+
+def register_servicemap(app: typer.Typer) -> None:
+    @app.command(help="Service endpoint-model relationship map")
+    def servicemap(
+        service: str = typer.Argument(..., help="Service name or path"),
+        root: str = typer.Option(".", help="Project root directory"),
+        save: bool = typer.Option(False, "--save", "-s", help="Save output to file"),
+    ) -> None:
+        target, project_root = _resolve_service_file(service, root=root)
+
+        analyzer = ANALYZERS.get(target.suffix.lower())
+        if analyzer is None:
+            raise InvalidPathError(message="Unsupported file type", path=target)
+
+        result = analyzer(target, project_root)
+        lines = _render_service_map(result)
+
+        if save:
+            out_path = project_root / f"codeintel-servicemap-{result['service_name']}.txt"
+            out_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+            typer.echo(f"Saved: {out_path.as_posix()}")
+        else:
+            typer.echo("\n" + "\n".join(lines))

codeintel_cli/commands/project/tree_cmd.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import typer
+
+# Optional: pip install pathspec
+try:
+    import pathspec  # type: ignore
+except Exception:  # pragma: no cover
+    pathspec = None
+
+
+DEFAULT_IGNORE_NAMES = {
+    ".git", ".idea", ".vscode",
+    "__pycache__", ".mypy_cache", ".pytest_cache", ".ruff_cache",
+    "venv", ".venv",
+    "node_modules", "dist", "build",
+    ".DS_Store",
+}
+
+
+@dataclass(frozen=True)
+class TreeOptions:
+    depth: int                 # -1 = unlimited
+    show_hidden: bool          # show dotfiles/dirs
+    keep_dotenv: bool          # always show ".env"
+    use_gitignore: bool        # apply .gitignore patterns
+    exts: tuple[str, ...]      # file extensions to include (".py", ".java")
+
+
+def _load_gitignore_spec(root: Path):
+    if pathspec is None:
+        return None
+    gi = root / ".gitignore"
+    if not gi.exists():
+        return None
+
+    lines: list[str] = []
+    for line in gi.read_text(encoding="utf-8", errors="ignore").splitlines():
+        s = line.strip()
+        if not s or s.startswith("#"):
+            continue
+        lines.append(s)
+
+    if not lines:
+        return None
+    return pathspec.PathSpec.from_lines("gitwildmatch", lines)
+
+
+def _is_hidden(name: str) -> bool:
+    return name.startswith(".")
+
+
+def _gitignore_matches(spec, rel_posix: str, is_dir: bool) -> bool:
+    if spec is None:
+        return False
+    if spec.match_file(rel_posix):
+        return True
+    if is_dir and spec.match_file(rel_posix.rstrip("/") + "/"):
+        return True
+    return False
+
+
+def _is_ignored(root: Path, p: Path, spec, opts: TreeOptions) -> bool:
+    name = p.name
+
+    if opts.keep_dotenv and name == ".env":
+        return False
+
+    if name in DEFAULT_IGNORE_NAMES:
+        return True
+
+    if _is_hidden(name) and not opts.show_hidden:
+        return True
+
+    if opts.use_gitignore and spec is not None:
+        rel = p.relative_to(root).as_posix()
+        if _gitignore_matches(spec, rel, p.is_dir()):
+            return True
+
+    return False
+
+
+def _is_source_file(p: Path, opts: TreeOptions) -> bool:
+    if not p.is_file():
+        return False
+    # include only selected extensions
+    return p.suffix.lower() in opts.exts
+
+
+def _list_children(root: Path, cur: Path, spec, opts: TreeOptions) -> list[Path]:
+    try:
+        entries = list(cur.iterdir())
+    except (PermissionError, FileNotFoundError):
+        return []
+
+    kept: list[Path] = []
+    for p in entries:
+        if _is_ignored(root, p, spec, opts):
+            continue
+        if p.is_dir():
+            kept.append(p)
+        else:
+            if _is_source_file(p, opts) or (opts.keep_dotenv and p.name == ".env"):
+                kept.append(p)
+
+    # dirs first, then files; alpha
+    kept.sort(key=lambda x: (x.is_file(), x.name.lower()))
+    return kept
+
+
+def _dir_has_visible_sources(root: Path, cur: Path, spec, opts: TreeOptions, remaining_depth: int) -> bool:
+    """
+    True if this directory contains any visible source file (directly or deeper).
+    remaining_depth: how many more levels we can descend; -1 for unlimited.
+    """
+    children = _list_children(root, cur, spec, opts)
+    if not children:
+        return False
+
+    for c in children:
+        if c.is_file():
+            return True
+
+    if remaining_depth == 0:
+        # we can't descend further; if it has dirs but no files shown, treat as empty
+        return False
+
+    next_depth = -1 if remaining_depth == -1 else remaining_depth - 1
+    for c in children:
+        if c.is_dir() and _dir_has_visible_sources(root, c, spec, opts, next_depth):
+            return True
+
+    return False
+
+
+def _print_tree(root: Path, opts: TreeOptions) -> None:
+    spec = _load_gitignore_spec(root) if opts.use_gitignore else None
+
+    def walk(cur: Path, prefix: str, level: int) -> None:
+        if opts.depth != -1 and level > opts.depth:
+            return
+
+        items = _list_children(root, cur, spec, opts)
+
+        # prune empty dirs (dirs that contain no visible sources)
+        pruned: list[Path] = []
+        for p in items:
+            if p.is_dir():
+                remaining = -1 if opts.depth == -1 else max(opts.depth - level, 0)
+                if _dir_has_visible_sources(root, p, spec, opts, remaining):
+                    pruned.append(p)
+            else:
+                pruned.append(p)
+
+        items = pruned
+
+        for i, p in enumerate(items):
+            last = i == len(items) - 1
+            branch = "└── " if last else "├── "
+            typer.echo(prefix + branch + p.name)
+
+            if p.is_dir():
+                extension = "    " if last else "│   "
+                walk(p, prefix + extension, level + 1)
+
+    typer.echo(root.name)
+    walk(root, prefix="", level=1)
+
+
+def register_tree(app: typer.Typer) -> None:
+    @app.command(help="Tree view of source files only (python/java).")
+    def tree(
+        root: str = typer.Argument(".", help="Folder to print tree for"),
+        depth: int = typer.Option(12, "--depth", help="Max depth (-1 = unlimited)"),
+        hidden: bool = typer.Option(False, "--hidden", help="Show hidden dotfiles/folders"),
+        no_gitignore: bool = typer.Option(False, "--no-gitignore", help="Do not apply .gitignore rules"),
+        keep_dotenv: bool = typer.Option(True, "--keep-dotenv/--no-keep-dotenv", help="Always show .env"),
+        lang: str = typer.Option("all", "--lang", help="all | py | java"),
+    ):
+        root_path = Path(root).resolve()
+        if not root_path.exists() or not root_path.is_dir():
+            raise typer.BadParameter(f"Invalid folder: {root_path}")
+
+        lang_norm = lang.strip().lower()
+        if lang_norm == "py":
+            exts = (".py",)
+        elif lang_norm == "java":
+            exts = (".java",)
+        elif lang_norm == "all":
+            exts = (".py", ".java")
+        else:
+            raise typer.BadParameter("Invalid --lang. Use: all | py | java")
+
+        opts = TreeOptions(
+            depth=depth,
+            show_hidden=hidden,
+            keep_dotenv=keep_dotenv,
+            use_gitignore=not no_gitignore,
+            exts=exts,
+        )
+        _print_tree(root_path, opts)

codeintel_cli/commands/project/version_cmd.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import typer
+import importlib.metadata as md
+from ...core.resolve_target import resolve_target_file
+
+
+def register_version(app: typer.Typer) -> None:
+    @app.command(help="Show CodeIntel version.")
+    def version():
+        try:
+            typer.echo(md.version("codeintel"))
+        except md.PackageNotFoundError:
+            typer.echo("codeintel (not installed as a package)")

codeintel_cli/context/java_context.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import re
+from collections import deque
+from pathlib import Path
+import typer
+
+from ..graph.builder import build_graph_with_counts, get_hub_files_by_ratio
+from ..lang.router import extract_imports
+
+TYPE = re.compile(r"\b(class|interface|enum|record)\s+([A-Za-z_][A-Za-z0-9_]*)\b")
+
+
+def _java_types_only(path: Path) -> list[str]:
+    out: list[str] = []
+    try:
+        for line in path.read_text(errors="ignore").splitlines():
+            m = TYPE.search(line)
+            if m:
+                kind = m.group(1)
+                name = m.group(2)
+                label = f"{name} ({kind})"
+                if label not in out:
+                    out.append(label)
+    except Exception:
+        return out
+    return out
+
+
+def _collect_java_imports(files: list[Path]) -> list[str]:
+    acc: set[str] = set()
+    for f in files:
+        if f.suffix != ".java":
+            continue
+        for imp in extract_imports(f, "java"):
+            acc.add(str(imp))
+    return sorted(acc)
+
+
+def _print_files_with_types(title: str, files: list[Path], root: Path) -> None:
+    typer.echo(title)
+    if not files:
+        typer.echo("  (none)")
+        typer.echo("")
+        return
+
+    any_printed = False
+    for f in files:
+        if f.suffix != ".java":
+            continue
+        types_ = _java_types_only(f)
+        if not types_:
+            continue
+        any_printed = True
+        typer.echo(f"• {f.relative_to(root)}")
+        for t in types_:
+            typer.echo(f"   {t}")
+        typer.echo("")
+
+    if not any_printed:
+        typer.echo("  (none)")
+        typer.echo("")
+        return
+
+
+def _print_imports(title: str, files: list[Path]) -> None:
+    typer.echo(title)
+    imps = _collect_java_imports(files)
+    if imps:
+        for x in imps:
+            typer.echo(f"  {x}")
+    else:
+        typer.echo("  (none)")
+    typer.echo("")
+
+
+def _build_reverse_graph(graph: dict[Path, set[Path]]) -> dict[Path, set[Path]]:
+    rev: dict[Path, set[Path]] = {}
+    for src, deps in graph.items():
+        for dep in deps:
+            rev.setdefault(dep, set()).add(src)
+    return rev
+
+
+def _bfs_layers(
+    graph: dict[Path, set[Path]],
+    start: Path,
+    depth: int,
+    *,
+    include_reverse: bool,
+    hubs: set[Path],
+) -> dict[int, set[Path]]:
+    if depth <= 0:
+        return {}
+
+    rev = _build_reverse_graph(graph) if include_reverse else {}
+    layers: dict[int, set[Path]] = {}
+    visited: set[Path] = {start}
+
+    q: deque[tuple[Path, int]] = deque()
+    q.append((start, 0))
+
+    while q:
+        node, d = q.popleft()
+        if d >= depth:
+            continue
+
+        neighbors: set[Path] = set()
+        neighbors |= graph.get(node, set())
+        if include_reverse:
+            neighbors |= rev.get(node, set())
+
+        for nb in neighbors:
+            if nb in visited:
+                continue
+            if hubs and nb in hubs:
+                continue
+            visited.add(nb)
+            nd = d + 1
+            layers.setdefault(nd, set()).add(nb)
+            q.append((nb, nd))
+
+    return layers
+
+
+def run_java_context(
+    *,
+    target: Path,
+    root: Path,
+    all_files: list[Path],
+    depth: int,
+    forward_only: bool,
+    include_hubs: bool,
+) -> None:
+    graph, dependents_count = build_graph_with_counts(all_files, root)
+
+    hubs: set[Path] = set()
+    if not include_hubs:
+        hubs = get_hub_files_by_ratio(dependents_count, len(all_files), 0.5)
+
+    same_folder = sorted(
+        f
+        for f in all_files
+        if f.suffix == ".java" and f.parent == target.parent and f != target
+    )
+
+    layers = _bfs_layers(
+        graph,
+        target,
+        depth=max(depth, 1),
+        include_reverse=not forward_only,
+        hubs=hubs,
+    )
+
+    level1_files = sorted(layers.get(1, set()))
+    level2_files = sorted(layers.get(2, set())) if depth >= 2 else []
+
+    typer.echo("")
+    typer.echo("CONTEXT")
+    typer.echo(f"Target: {target.relative_to(root)}")
+    typer.echo(f"Depth: {depth}  Mode: {'forward-only' if forward_only else 'forward+reverse'}")
+    typer.echo("")
+
+    typer.echo("TARGET IMPORTS")
+    t_imps = extract_imports(target, "java")
+    if t_imps:
+        for x in t_imps:
+            typer.echo(f"  {x}")
+    else:
+        typer.echo("  (none)")
+    typer.echo("")
+
+    _print_files_with_types("SAME FOLDER TYPES", same_folder, root)
+
+    _print_files_with_types("RELATED LEVEL 1 TYPES", level1_files, root)
+    _print_imports("RELATED LEVEL 1 IMPORTS", level1_files)
+
+    if depth >= 2:
+        _print_files_with_types("RELATED LEVEL 2 TYPES", level2_files, root)
+        _print_imports("RELATED LEVEL 2 IMPORTS", level2_files)