aja-codeintel 0.1.5__tar.gz → 0.1.6__tar.gz

{aja_codeintel-0.1.5 → aja_codeintel-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aja-codeintel
-Version: 0.1.5
+Version: 0.1.6
 Summary: CodeIntel CLI tool
 Author: Shiva Areti
 License: MIT License

{aja_codeintel-0.1.5 → aja_codeintel-0.1.6}/aja_codeintel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aja-codeintel
-Version: 0.1.5
+Version: 0.1.6
 Summary: CodeIntel CLI tool
 Author: Shiva Areti
 License: MIT License

{aja_codeintel-0.1.5 → aja_codeintel-0.1.6}/aja_codeintel.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ codeintel_cli/commands/nav/where_cmd.py
 codeintel_cli/commands/project/__init__.py
 codeintel_cli/commands/project/context_cmd.py
 codeintel_cli/commands/project/endpoints_cmd.py
+codeintel_cli/commands/project/errors_cmd.py
 codeintel_cli/commands/project/folder_cmd.py
 codeintel_cli/commands/project/frontend_cmd.py
 codeintel_cli/commands/project/imports_cmd.py
@@ -70,6 +71,7 @@ codeintel_cli/graph/traverse.py
 codeintel_cli/lang/__init__.py
 codeintel_cli/lang/router.py
 codeintel_cli/lang/java/__init__.py
+codeintel_cli/lang/java/ast_engine.py
 codeintel_cli/lang/java/engine.py
 codeintel_cli/lang/java/models.py
 codeintel_cli/lang/java/resolve.py

{aja_codeintel-0.1.5 → aja_codeintel-0.1.6}/codeintel_cli/commands/project/__init__.py

@@ -17,7 +17,8 @@ def register_project_commands(app: typer.Typer) -> None:
     from .servicemap_cmd import register_servicemap
     from .modeltree_cmd import register_modeltree
     from .version_cmd import register_version
-    from .frontend_cmd import register_frontend
+    from .frontend_cmd import register_frontend
+    from .errors_cmd import register_errors
 
     register_overview(app)
     register_models(app)
@@ -32,4 +33,5 @@ def register_project_commands(app: typer.Typer) -> None:
     register_servicemap(app)
     register_modeltree(app)
     register_version(app)
-    register_frontend(app)
+    register_frontend(app)
+    register_errors(app)

aja_codeintel-0.1.6/codeintel_cli/commands/project/errors_cmd.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ...core.project import find_project_root
+from ...scanner.scanner import find_all_supported_files
+from ...db.cache import CacheManager
+
+
+# ─────────────────────────── helpers ────────────────────────────
+
+def _find_maven_cmd(root: Path) -> str:
+    for name in ["mvnw.cmd", "mvnw"]:
+        if (root / name).exists():
+            return str(root / name)
+    return "mvn"
+
+
+def _changed_files(project_root: Path) -> list[Path]:
+    """Return java files modified since last scan."""
+    try:
+        cache = CacheManager(project_root)
+        cached = {Path(p) for p in cache.get_cached_files()}
+        changed = []
+        for p in cached:
+            if not p.exists():
+                continue
+            db_mtime = cache.get_file_mtime(p)
+            if db_mtime is None or p.stat().st_mtime > db_mtime:
+                changed.append(p)
+        return changed
+    except Exception:
+        return []
+
+
+# ─────────────────────── mvn compile errors ─────────────────────
+
+_MVN_ERROR_RE = re.compile(
+    r'^\[ERROR\]\s+(.+?\.java):\[(\d+),\d+\]\s+(.+)$'
+)
+_MVN_WARNING_RE = re.compile(
+    r'^\[WARNING\]\s+(.+?\.java):\[(\d+),\d+\]\s+(.+)$'
+)
+
+
+def _run_mvn_compile(project_root: Path) -> tuple[list[dict], list[dict]]:
+    mvn = _find_maven_cmd(project_root)
+    try:
+        result = subprocess.run(
+            f'"{mvn}" compile -q --batch-mode',
+            cwd=str(project_root),
+            capture_output=True,
+            text=True,
+            shell=True,
+            timeout=120,
+        )
+        output = result.stdout + result.stderr
+    except subprocess.TimeoutExpired:
+        return [], [{"file": "?", "line": "?", "msg": "mvn compile timed out after 120s"}]
+    except Exception as e:
+        return [], [{"file": "?", "line": "?", "msg": str(e)}]
+
+    errors: list[dict] = []
+    warnings: list[dict] = []
+    for line in output.splitlines():
+        m = _MVN_ERROR_RE.match(line.strip())
+        if m:
+            errors.append({"file": Path(m.group(1)).name, "line": m.group(2), "msg": m.group(3).strip()})
+            continue
+        m = _MVN_WARNING_RE.match(line.strip())
+        if m:
+            warnings.append({"file": Path(m.group(1)).name, "line": m.group(2), "msg": m.group(3).strip()})
+    return errors, warnings
+
+
+# ──────────────────────── static analysis ───────────────────────
+
+# Patterns: (regex, message, severity)
+_STATIC_CHECKS: list[tuple[re.Pattern, str, str]] = [
+    # Empty catch block
+    (re.compile(r'catch\s*\([^)]+\)\s*\{\s*\}'), "Empty catch block swallows exception", "warning"),
+    # Null dereference risk: .get() without check
+    (re.compile(r'\.get\(\)\s*\.'), "Possible null dereference after .get()", "warning"),
+    # Syso debug prints left in
+    (re.compile(r'System\.out\.print'), "Debug System.out.print left in code", "warning"),
+    # TODO/FIXME left in
+    (re.compile(r'//\s*(TODO|FIXME|HACK|XXX)\b'), "Unresolved TODO/FIXME comment", "info"),
+    # Catching raw Exception
+    (re.compile(r'catch\s*\(\s*Exception\s+\w+\s*\)'), "Catching raw Exception — too broad", "warning"),
+    # Unused import hint (simple heuristic)
+    (re.compile(r'^import\s+java\.util\.(Vector|Hashtable|Stack)\s*;', re.MULTILINE), "Outdated collection type import", "info"),
+    # Magic numbers (not 0/1/-1)
+    (re.compile(r'(?<![.\w])[2-9]\d{2,}(?![.\w])'), "Magic number — consider named constant", "info"),
+    # String == comparison
+    (re.compile(r'==\s*"[^"]*"'), 'String compared with == instead of .equals()', "error"),
+    # Mutable static field
+    (re.compile(r'static\s+(?!final)\w+\s+\w+\s*='), "Mutable static field — potential concurrency issue", "warning"),
+    # NullPointerException throw without message
+    (re.compile(r'throw\s+new\s+NullPointerException\s*\(\s*\)'), "NullPointerException thrown without message", "warning"),
+]
+
+_SKIP_DIRS = {"target", "build", ".git", "test", "tests"}
+
+
+def _static_analyze(files: list[Path]) -> list[dict]:
+    issues: list[dict] = []
+    for f in files:
+        if any(part in _SKIP_DIRS for part in f.parts):
+            continue
+        try:
+            lines = f.read_text(encoding="utf-8", errors="ignore").splitlines()
+        except Exception:
+            continue
+        for lineno, line in enumerate(lines, 1):
+            stripped = line.strip()
+            if stripped.startswith("//") and not re.match(r'//\s*(TODO|FIXME)', stripped):
+                continue  # skip pure comment lines except TODO/FIXME
+            for pattern, msg, severity in _STATIC_CHECKS:
+                if pattern.search(line):
+                    issues.append({
+                        "file": f.name,
+                        "line": str(lineno),
+                        "msg": msg,
+                        "severity": severity,
+                    })
+                    break  # one issue per line
+    return issues
+
+
+# ────────────────────────── renderer ────────────────────────────
+
+_SEV_ORDER = {"error": 0, "warning": 1, "info": 2}
+_SEV_LABEL = {"error": "ERROR", "warning": "WARN ", "info": "INFO "}
+
+
+def _render(
+    compile_errors: list[dict],
+    compile_warnings: list[dict],
+    static_issues: list[dict],
+) -> list[str]:
+    out: list[str] = []
+    total = len(compile_errors) + len(compile_warnings) + len(static_issues)
+
+    if total == 0:
+        return ["✓ No issues found."]
+
+    # ── Compile errors
+    if compile_errors:
+        out.append(f"COMPILE ERRORS ({len(compile_errors)})")
+        out.append("─" * 60)
+        for e in compile_errors:
+            pad = max(0, 30 - len(e["file"]))
+            out.append(f"  {e['file']}{' '*pad} line {e['line']:<6}  {e['msg']}")
+        out.append("")
+
+    # ── Compile warnings
+    if compile_warnings:
+        out.append(f"COMPILE WARNINGS ({len(compile_warnings)})")
+        out.append("─" * 60)
+        for w in compile_warnings:
+            pad = max(0, 30 - len(w["file"]))
+            out.append(f"  {w['file']}{' '*pad} line {w['line']:<6}  {w['msg']}")
+        out.append("")
+
+    # ── Static issues grouped by severity
+    if static_issues:
+        static_issues.sort(key=lambda x: (_SEV_ORDER.get(x["severity"], 9), x["file"], int(x["line"])))
+        by_sev: dict[str, list[dict]] = {}
+        for i in static_issues:
+            by_sev.setdefault(i["severity"], []).append(i)
+        for sev in ("error", "warning", "info"):
+            group = by_sev.get(sev, [])
+            if not group:
+                continue
+            label = {"error": "STATIC ERRORS", "warning": "STATIC WARNINGS", "info": "STATIC INFO"}[sev]
+            out.append(f"{label} ({len(group)})")
+            out.append("─" * 60)
+            for i in group:
+                pad = max(0, 30 - len(i["file"]))
+                out.append(f"  {i['file']}{' '*pad} line {i['line']:<6}  {i['msg']}")
+            out.append("")
+
+    out.append(f"{'─'*60}")
+    out.append(f"  Total: {len(compile_errors)} compile error(s), {len(compile_warnings)} compile warning(s), {len(static_issues)} static issue(s)")
+    return out
+
+
+# ─────────────────────────── command ────────────────────────────
+
+def register_errors(app: typer.Typer) -> None:
+    @app.command("errors", help="Show compile errors + static analysis issues.")
+    def errors(
+        path: str = typer.Argument(".", help="Project root folder"),
+        changed_only: bool = typer.Option(False, "--changed-only", "-c", help="Only scan files changed since last aja scan"),
+        skip_compile: bool = typer.Option(False, "--skip-compile", help="Skip mvn compile, only run static analysis"),
+        skip_static: bool = typer.Option(False, "--skip-static", help="Skip static analysis, only run mvn compile"),
+        verbose: bool = typer.Option(False, "--verbose", "-v", help="Show INFO level issues"),
+    ) -> None:
+        t0 = time.perf_counter()
+        project_root = find_project_root(Path(path).resolve())
+
+        # Collect files for static analysis
+        if changed_only:
+            java_files = _changed_files(project_root)
+            typer.echo(f"Scanning {len(java_files)} changed file(s)...")
+        else:
+            java_files = [
+                f for f in find_all_supported_files(project_root)
+                if f.suffix.lower() == ".java"
+            ]
+            typer.echo(f"Scanning {len(java_files)} Java file(s)...")
+        typer.echo("")
+
+        compile_errors: list[dict] = []
+        compile_warnings: list[dict] = []
+        static_issues: list[dict] = []
+
+        if not skip_compile:
+            typer.echo("Running mvn compile...")
+            compile_errors, compile_warnings = _run_mvn_compile(project_root)
+
+        if not skip_static:
+            static_issues = _static_analyze(java_files)
+            if not verbose:
+                static_issues = [i for i in static_issues if i["severity"] != "info"]
+
+        for line in _render(compile_errors, compile_warnings, static_issues):
+            typer.echo(line)
+
+        elapsed = time.perf_counter() - t0
+        typer.echo(f"\nFinished in {elapsed:.3f}s")
+

aja_codeintel-0.1.6/codeintel_cli/commands/project/modeltree_cmd.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+from collections import deque
+from pathlib import Path
+import os, subprocess, sys
+import typer
+
+from ...errors import InvalidPathError
+from ...core.resolve_model_target import resolve_model_target_file as _resolve_model_target_file
+from ...core.resolve_model_target import _is_java_model_file
+from ...lang.java.resolve import resolve_java_import_to_file
+from ...graph.builder import build_graph_with_counts, get_hub_files_by_ratio
+from ...context.java_rel import clean_java, top_type_name, java_fields_and_rels, model_fields_from_extractor, Rel
+from ...db.cache import CacheManager
+
+
+def _get_cached_files(project_root: Path) -> list[Path]:
+    with CacheManager(project_root) as cache:
+        if cache.needs_rescan():
+            cache.scan_project(verbose=False)
+        return [p.resolve() for p in cache.get_cached_files()]
+
+def _fmt_fields(fields, indent="  ") -> list[str]:
+    return [f"{indent}- {n}: {t}" + (" (PK)" if pk else "") for n, t, pk in fields]
+
+def _rel_label(kind: str) -> str:
+    return {"OneToOne":"1:1","OneToMany":"1:N","ManyToMany":"N:M","ManyToOne":"N:1"}.get(kind, kind)
+
+def _rel_meta(r: Rel) -> str:
+    parts = []
+    if r.mapped_by: parts.append(f"mappedBy={r.mapped_by}")
+    if r.join_table: parts.append(f"joinTable={r.join_table}")
+    if r.join_columns: parts.append("joinCols="+",".join(r.join_columns))
+    return (" ["+"; ".join(parts)+"]") if parts else ""
+
+def _default_outfile(root: Path, name: str) -> Path:
+    base = root / f"codeintel-modeltree-{name}.txt"
+    if not base.exists(): return base
+    i = 2
+    while True:
+        p = root / f"codeintel-modeltree-{name}-{i}.txt"
+        if not p.exists(): return p
+        i += 1
+
+def _open_in_editor(path: Path) -> None:
+    p = path.resolve()
+    try:
+        from ...core.opener import open_file
+        open_file(p); return
+    except Exception: pass
+    try:
+        subprocess.Popen(["code", str(p)], close_fds=True); return
+    except Exception: pass
+    try:
+        if sys.platform.startswith("win"):
+            subprocess.Popen(["cmd","/c","start","",str(p)], close_fds=True)
+    except Exception: pass
+
+def _java_model_scope_from_files(files: list[Path]) -> list[Path]:
+    return [p.resolve() for p in files if _is_java_model_file(p)]
+
+def _layered_related(graph, start, depth, include_reverse, hubs):
+    adj = {k: set(v) for k, v in graph.items()}
+    if include_reverse:
+        rev = {}
+        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 = {start}
+    q = deque([(start, 0)])
+    by_depth = {}
+    while q:
+        node, d = q.popleft()
+        if d == depth: continue
+        for nxt in adj.get(node, set()):
+            if nxt in visited or nxt in hubs: continue
+            visited.add(nxt)
+            nd = d + 1
+            by_depth.setdefault(nd, []).append(nxt)
+            q.append((nxt, nd))
+    return [sorted(by_depth.get(i, [])) for i in range(1, depth+1)]
+
+def _file_for_java_class(name, scope, root):
+    if not name: return None
+    exact = [p for p in scope if p.suffix.lower()==".java" and p.stem==name]
+    if exact: return exact[0].resolve()
+    try:
+        p = resolve_java_import_to_file(name, root)
+        if p and p.exists(): return p.resolve()
+    except Exception: pass
+    return None
+
+def _collect_java_relationship_map(target, project_root, depth, forward_only, include_hubs):
+    all_files = _get_cached_files(project_root)
+    graph, dep_counts = build_graph_with_counts(all_files, project_root, use_sqlite_cache=True)
+    hubs = set()
+    if not include_hubs:
+        hubs = get_hub_files_by_ratio(dep_counts, len(all_files), 0.5)
+    layers = _layered_related(graph, target.resolve(), depth, not forward_only, hubs)
+    model_files = set(_java_model_scope_from_files(all_files))
+    scope = [rp for layer in layers for p in layer if (rp := p.resolve()) in model_files]
+    try:
+        text = clean_java(target.read_text(encoding="utf-8", errors="ignore"))
+    except Exception:
+        text = ""
+    model_name = top_type_name(text, target.stem)
+    main_fields, main_rels = java_fields_and_rels(target)
+    fields_by_entity = {}
+    for r in main_rels:
+        if not r or not r.target: continue
+        p = _file_for_java_class(r.target, scope+[target], project_root)
+        if p and p.exists():
+            flds = model_fields_from_extractor(p, project_root) or []
+            if not flds:
+                flds, _ = java_fields_and_rels(p)
+            if flds:
+                fields_by_entity[r.target] = flds
+    # Cached reverse scan — build once per project_root per process
+    import functools
+    cache_key = str(project_root.resolve())
+    if not hasattr(_collect_java_relationship_map, "_rev_cache"):
+        _collect_java_relationship_map._rev_cache = {}
+    if cache_key not in _collect_java_relationship_map._rev_cache:
+        rev_map: dict[str, list[tuple]] = {}
+        rev_fields: dict[str, list] = {}
+        for p in model_files:
+            try:
+                t = clean_java(p.read_text(encoding="utf-8", errors="ignore"))
+            except Exception:
+                continue
+            src_name = top_type_name(t, p.stem)
+            _, rels = java_fields_and_rels(p)
+            for rr in rels:
+                if not rr or not rr.target:
+                    continue
+                rev_map.setdefault(rr.target, []).append((src_name, rr))
+                if src_name not in rev_fields:
+                    flds = model_fields_from_extractor(p, project_root) or []
+                    if not flds:
+                        flds, _ = java_fields_and_rels(p)
+                    if flds:
+                        rev_fields[src_name] = flds
+        _collect_java_relationship_map._rev_cache[cache_key] = (rev_map, rev_fields)
+    rev_map, rev_fields = _collect_java_relationship_map._rev_cache[cache_key]
+    reverse = sorted(rev_map.get(model_name, []), key=lambda x: (x[0].lower(), x[1].kind, x[1].field.lower()))
+    for src_name, _ in reverse:
+        if src_name not in fields_by_entity and src_name in rev_fields:
+            fields_by_entity[src_name] = rev_fields[src_name]
+    return model_name, main_fields, main_rels, fields_by_entity, reverse
+
+
+def _view_tree(model, fields, rels, fields_by, reverse):
+    lines = [model, "+- Fields"]
+    for n,t,pk in fields:
+        lines.append(f"|  +- {n}: {t}" + (" (PK)" if pk else ""))
+    lines.append("|")
+    groups = {}
+    for r in rels:
+        groups.setdefault(r.kind, []).append(r)
+    order = ["OneToOne","OneToMany","ManyToMany","ManyToOne"]
+    kinds = [k for k in order if k in groups]
+    if not kinds:
+        lines += ["+- Relationships", "   +- (none)"]
+    else:
+        for ki, kind in enumerate(kinds):
+            kpad = "   " if ki==len(kinds)-1 else "|  "
+            lines.append(f"+- @{kind}")
+            for ri, r in enumerate(groups[kind]):
+                rlast = ri==len(groups[kind])-1
+                suffix = "[]" if kind in {"OneToMany","ManyToMany"} else ""
+                lines.append(f"{kpad}+- {r.target}{suffix}  (field: {r.field}){_rel_meta(r)}")
+                for fn,ft,_ in fields_by.get(r.target,[]):
+                    lines.append(f"{kpad}{'   ' if rlast else '|  '}   +- {fn}: {ft}")
+    lines += ["","Reverse References:"]
+    lines += [f"  <- {s} (@{r.kind} via {r.field}){_rel_meta(r)}" for s,r in reverse] or ["  (none)"]
+    return lines
+
+
+def register_modeltree(app: typer.Typer) -> None:
+    @app.command(help="Model relationship tree")
+    def modeltree(
+        model: str = typer.Argument(...),
+        root: str = typer.Option("."),
+        depth: int = typer.Option(2, "--depth", "-d"),
+        forward_only: bool = typer.Option(False, "--forward-only"),
+        include_hubs: bool = typer.Option(False, "--include-hubs"),
+        out: Path | None = typer.Option(None, "--out"),
+    ) -> None:
+        auto = os.environ.get("AJA_AUTO") == "1"
+        target, project_root = _resolve_model_target_file(model, root=root)
+
+        if target.suffix.lower() != ".java":
+            raise InvalidPathError(message="Java-only mode: only .java model files supported", path=target)
+        if not _is_java_model_file(target):
+            raise InvalidPathError(message="Not a model/entity file", path=target)
+
+        model_name, fields, rels, fields_by, reverse = _collect_java_relationship_map(
+            target, project_root, depth, forward_only, include_hubs
+        )
+        lines = _view_tree(model_name, fields, rels, fields_by, reverse)
+
+        # Always print to terminal
+        typer.echo("")
+        for ln in lines:
+            typer.echo(ln)
+
+        # Ask user if they want to save (skip in auto mode)
+        save = False if auto else typer.confirm("\nSave to file?", default=False)
+        if save:
+            out_path = out.resolve() if out else _default_outfile(project_root, model_name)
+            out_path.write_text("\n".join(lines)+"\n", encoding="utf-8")
+            typer.echo(out_path.as_posix())
+            _open_in_editor(out_path)
+
+
+