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

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

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

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

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

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

@@ -23,6 +23,7 @@ codeintel_cli/commands/nav/open_cmd.py
 codeintel_cli/commands/nav/where_cmd.py
 codeintel_cli/commands/project/__init__.py
 codeintel_cli/commands/project/context_cmd.py
+codeintel_cli/commands/project/debug_cmd.py
 codeintel_cli/commands/project/endpoints_cmd.py
 codeintel_cli/commands/project/errors_cmd.py
 codeintel_cli/commands/project/folder_cmd.py
@@ -72,9 +73,17 @@ 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/auth.py
+codeintel_cli/lang/java/base_path.py
+codeintel_cli/lang/java/call_graph.py
 codeintel_cli/lang/java/engine.py
+codeintel_cli/lang/java/enums.py
+codeintel_cli/lang/java/method_index.py
 codeintel_cli/lang/java/models.py
+codeintel_cli/lang/java/pagination.py
 codeintel_cli/lang/java/resolve.py
+codeintel_cli/lang/java/types.py
+codeintel_cli/lang/java/validation.py
 codeintel_cli/lang/python/__init__.py
 codeintel_cli/lang/python/engine.py
 codeintel_cli/lang/python/models.py
@@ -82,4 +91,7 @@ codeintel_cli/parser/imports.py
 codeintel_cli/parser/resolve.py
 codeintel_cli/parser/symbols.py
 codeintel_cli/scanner/__init__.py
-codeintel_cli/scanner/scanner.py
+codeintel_cli/scanner/scanner.py
+codeintel_cli/terminal/__init__.py
+codeintel_cli/terminal/error_parser.py
+codeintel_cli/terminal/printer.py

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

@@ -1,37 +1,38 @@
-from __future__ import annotations
-
-import typer
-
-
-def register_project_commands(app: typer.Typer) -> None:
-    from .overview_cmd import register_overview
-    from .models_cmd import register_models
-    from .endpoints_cmd import register_endpoints
-    from .types_cmd import register_types_command
-    from .scan_cmd import register_scan
-    from .context_cmd import register_context
-    from .tree_cmd import register_tree
-    from .imports_cmd import register_imports
-    from .folder_cmd import register_folder
-    from .resolve_cmd import register_resolve
-    from .servicemap_cmd import register_servicemap
-    from .modeltree_cmd import register_modeltree
-    from .version_cmd import register_version
+from __future__ import annotations
+import typer
+
+
+def register_project_commands(app: typer.Typer) -> None:
+    from .overview_cmd import register_overview
+    from .models_cmd import register_models
+    from .endpoints_cmd import register_endpoints
+    from .types_cmd import register_types_command
+    from .scan_cmd import register_scan
+    from .context_cmd import register_context
+    from .tree_cmd import register_tree
+    from .imports_cmd import register_imports
+    from .folder_cmd import register_folder
+    from .resolve_cmd import register_resolve
+    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 .errors_cmd import register_errors
-
-    register_overview(app)
-    register_models(app)
-    register_endpoints(app)
-    register_types_command(app)
-    register_scan(app)
-    register_context(app)
-    register_tree(app)
-    register_imports(app)
-    register_folder(app)
-    register_resolve(app)
-    register_servicemap(app)
-    register_modeltree(app)
-    register_version(app)
+    from .errors_cmd import register_errors
+    from .debug_cmd import register_debug
+
+    register_overview(app)
+    register_models(app)
+    register_endpoints(app)
+    register_types_command(app)
+    register_scan(app)
+    register_context(app)
+    register_tree(app)
+    register_imports(app)
+    register_folder(app)
+    register_resolve(app)
+    register_servicemap(app)
+    register_modeltree(app)
+    register_version(app)
     register_frontend(app)
-    register_errors(app)
+    register_errors(app)
+    register_debug(app)

aja_codeintel-0.1.8/codeintel_cli/commands/project/debug_cmd.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+import time
+from pathlib import Path
+import typer
+from ...core.project import find_project_root
+
+
+def register_debug(app: typer.Typer) -> None:
+    @app.command("debug", help="Show exact error code blocks + call graph (callers/callees).")
+    def debug(
+        path: str = typer.Argument(".", help="Project root"),
+        skip_compile: bool = typer.Option(False, "--skip-compile"),
+        verbose: bool = typer.Option(False, "--verbose", "-v"),
+    ) -> None:
+        t0 = time.perf_counter()
+        project_root = find_project_root(Path(path).resolve())
+
+        from ...commands.project.errors_cmd import _run_mvn_compile
+        from ...lang.java.method_index import load_index, build_index, save_index, find_method_at_line
+        from ...lang.java.call_graph import build_call_graph, get_related
+        from ...terminal.printer import print_block
+        from ...terminal.error_parser import JavaError
+
+        compile_errors = []
+        if not skip_compile:
+            typer.echo("Running mvn compile...")
+            compile_errors, _, _ = _run_mvn_compile(project_root)
+
+        if not compile_errors:
+            typer.echo(typer.style("? No compile errors found.", fg=typer.colors.GREEN))
+            raise typer.Exit()
+
+        typer.echo(f"Found {len(compile_errors)} error(s). Building index + call graph...")
+
+        index = load_index(project_root)
+        if not index:
+            index = build_index(project_root)
+            save_index(project_root, index)
+
+        G = build_call_graph(index)
+
+        for e in compile_errors:
+            err = JavaError(file=e["file"], line=int(e["line"]), message=e["msg"])
+            method = find_method_at_line(index, e["file"], int(e["line"]))
+            if not method:
+                typer.echo(typer.style(f"\n[!] {e['file']}:{e['line']} — method not in index", fg=typer.colors.YELLOW))
+                continue
+            related = get_related(G, method["class"], method["method"])
+            print_block(err, method, project_root, related["callers"], related["callees"])
+
+        typer.echo(f"\nFinished in {time.perf_counter() - t0:.3f}s")

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

@@ -0,0 +1,222 @@
+from __future__ import annotations
+import re
+import subprocess
+import time
+import threading
+from pathlib import Path
+import typer
+from ...core.project import find_project_root
+from ...scanner.scanner import find_all_supported_files
+from ...db.cache import CacheManager
+
+
+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]:
+    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_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], str]:
+    mvn = _find_maven_cmd(project_root)
+    done = threading.Event()
+
+    def spinner():
+        chars = ["|", "/", "-", "\\"]
+        i = 0
+        start = time.perf_counter()
+        while not done.is_set():
+            elapsed = time.perf_counter() - start
+            typer.echo(f"\r  {chars[i % 4]}  mvn compile running... {elapsed:.0f}s", nl=False)
+            i += 1
+            time.sleep(0.2)
+        typer.echo("\r" + " " * 40 + "\r", nl=False)
+
+    t = threading.Thread(target=spinner, daemon=True)
+    t.start()
+
+    try:
+        result = subprocess.run(
+            f'"{mvn}" compile -q --batch-mode',
+            cwd=str(project_root),
+            capture_output=True, text=True, shell=True, timeout=300,
+        )
+        output = result.stdout + result.stderr
+    except subprocess.TimeoutExpired:
+        done.set()
+        return [], [{"file": "?", "line": "?", "msg": "mvn compile timed out"}], ""
+    except Exception as e:
+        done.set()
+        return [], [{"file": "?", "line": "?", "msg": str(e)}], ""
+    finally:
+        done.set()
+        t.join()
+
+    errors, warnings = [], []
+    seen_e, seen_w = set(), set()
+    for line in output.splitlines():
+        m = _MVN_ERROR_RE.match(line.strip())
+        if m:
+            k = (Path(m.group(1)).name, m.group(2))
+            if k not in seen_e:
+                seen_e.add(k)
+                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:
+            k = (Path(m.group(1)).name, m.group(2))
+            if k not in seen_w:
+                seen_w.add(k)
+                warnings.append({"file": Path(m.group(1)).name, "line": m.group(2), "msg": m.group(3).strip()})
+    return errors, warnings, output
+
+
+_STATIC_CHECKS = [
+    (re.compile(r'catch\s*\([^)]+\)\s*\{\s*\}'), "Empty catch block", "warning"),
+    (re.compile(r'\.get\(\)\s*\.'), "Possible null dereference after .get()", "warning"),
+    (re.compile(r'System\.out\.print'), "Debug System.out.print left in code", "warning"),
+    (re.compile(r'//\s*(TODO|FIXME|HACK|XXX)\b'), "Unresolved TODO/FIXME", "info"),
+    (re.compile(r'catch\s*\(\s*Exception\s+\w+\s*\)'), "Catching raw Exception", "warning"),
+    (re.compile(r'==\s*"[^"]*"'), 'String compared with == instead of .equals()', "error"),
+    (re.compile(r'static\s+(?!final)\w+\s+\w+\s*='), "Mutable static field", "warning"),
+    (re.compile(r'throw\s+new\s+NullPointerException\s*\(\s*\)'), "NullPointerException without message", "warning"),
+]
+_SKIP_DIRS = {"target", "build", ".git", "test", "tests"}
+
+
+def _static_analyze(files: list[Path]) -> list[dict]:
+    issues = []
+    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):
+            for pattern, msg, severity in _STATIC_CHECKS:
+                if pattern.search(line):
+                    issues.append({"file": f.name, "line": str(lineno), "msg": msg, "severity": severity})
+                    break
+    return issues
+
+
+_SEV_ORDER = {"error": 0, "warning": 1, "info": 2}
+
+
+def _render(compile_errors, compile_warnings, static_issues) -> list[str]:
+    out = []
+    if not compile_errors and not compile_warnings and not static_issues:
+        return ["No issues found."]
+    if compile_errors:
+        out.append(f"COMPILE ERRORS ({len(compile_errors)})")
+        out.append("-" * 60)
+        for e in compile_errors:
+            out.append(f"  {e['file']:<30} line {e['line']:<6}  {e['msg']}")
+        out.append("")
+    if compile_warnings:
+        out.append(f"COMPILE WARNINGS ({len(compile_warnings)})")
+        out.append("-" * 60)
+        for w in compile_warnings:
+            out.append(f"  {w['file']:<30} line {w['line']:<6}  {w['msg']}")
+        out.append("")
+    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] = {}
+        for i in static_issues:
+            by_sev.setdefault(i["severity"], []).append(i)
+        labels = {"error": "STATIC ERRORS", "warning": "STATIC WARNINGS", "info": "STATIC INFO"}
+        for sev in ("error", "warning", "info"):
+            group = by_sev.get(sev, [])
+            if group:
+                out.append(f"{labels[sev]} ({len(group)})")
+                out.append("-" * 60)
+                for i in group:
+                    out.append(f"  {i['file']:<30} line {i['line']:<6}  {i['msg']}")
+                out.append("")
+    out.append("-" * 60)
+    out.append(f"  Total: {len(compile_errors)} compile error(s), {len(compile_warnings)} warning(s), {len(static_issues)} static issue(s)")
+    return out
+
+
+def register_errors(app: typer.Typer) -> None:
+    @app.command("errors", help="Static analysis (instant). Add --compile to also run mvn compile.")
+    def errors(
+        path: str = typer.Argument(".", help="Project root"),
+        changed_only: bool = typer.Option(False, "--changed-only", "-c"),
+        compile: bool = typer.Option(False, "--compile", help="Also run mvn compile"),
+        skip_static: bool = typer.Option(False, "--skip-static"),
+        verbose: bool = typer.Option(False, "--verbose", "-v"),
+        block: bool = typer.Option(False, "--block", "-b", help="Show exact method code block for each compile error"),
+    ) -> None:
+        t0 = time.perf_counter()
+        project_root = find_project_root(Path(path).resolve())
+
+        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, compile_warnings, raw_output = [], [], ""
+
+        if compile or block:
+            compile_errors, compile_warnings, raw_output = _run_mvn_compile(project_root)
+
+        static_issues = []
+        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)
+
+        if block and compile_errors:
+            _show_blocks(project_root, compile_errors)
+        elif block and not compile_errors:
+            typer.echo("No compile errors to show blocks for.")
+
+        typer.echo(f"\nFinished in {time.perf_counter() - t0:.3f}s")
+
+
+def _show_blocks(project_root: Path, compile_errors: list[dict]) -> None:
+    from ...lang.java.method_index import load_index, build_index, save_index, find_method_at_line
+    from ...terminal.printer import print_block
+    from ...terminal.error_parser import JavaError
+
+    index = load_index(project_root)
+    if not index:
+        typer.echo("\nBuilding method index...")
+        index = build_index(project_root)
+        save_index(project_root, index)
+
+    for e in compile_errors:
+        err = JavaError(file=e["file"], line=int(e["line"]), message=e["msg"])
+        method = find_method_at_line(index, e["file"], int(e["line"]))
+        if method:
+            print_block(err, method, project_root)
+        else:
+            typer.echo(f"\n[!] {e['file']}:{e['line']} - method not in index")

aja_codeintel-0.1.8/codeintel_cli/commands/project/models_cmd.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from pathlib import Path
+import typer
+
+from ...core.project import find_project_root
+from ...scanner.scanner import find_all_supported_files
+
+
+MODEL_DIRS = {
+    "model", "models",
+    "entity", "entities",
+    "domain", "domains",
+    "core",
+    "aggregate", "aggregates",
+    "persistence",
+    "db", "data", "schema",
+    "pojo", "bean", "beans",
+    "orm", "schemas",
+    "datamodel", "datamodels",
+    "table", "tables",
+    "record", "records",
+    "document", "documents",
+    "dao",
+    # petclinic-style: models live in feature packages
+    "owner", "vet", "pet", "visit",
+}
+
+SKIP_DIRS = {
+    "test", "tests",
+    "controller", "controllers",
+    "service", "services",
+    "repository", "repositories",
+    "config", "configuration",
+    "util", "utils", "helper", "helpers",
+    "exception", "exceptions",
+    "security",
+    "mapper", "mappers",
+    "migration", "migrations",
+    "dto",
+}
+
+SKIP_SUFFIXES = (
+    "Repository", "Mapper", "Dao",
+    "Service", "Controller",
+    "Config", "Configuration",
+    "Util", "Utils", "Helper",
+    "Exception", "Handler",
+    "Interceptor", "Filter",
+    "Listener", "Scheduler",
+    "Validator", "Converter",
+    "Serializer", "Deserializer",
+    "Factory", "Builder",
+    "Specification",
+)
+
+# Annotations that definitively mark a class as a domain model
+_ENTITY_ANNOTATIONS = {
+    "Entity", "MappedSuperclass", "Embeddable",
+    "Table", "Document",
+}
+
+
+def _import_extractors():
+    py = None
+    jv = None
+    try:
+        from ...lang.python.models import extract_python_models as _py
+        py = _py
+    except Exception:
+        pass
+    try:
+        from ...context.python_context import extract_python_models as _py
+        py = _py
+    except Exception:
+        pass
+    try:
+        from ...lang.java.models import extract_java_models as _jv
+        jv = _jv
+    except Exception:
+        pass
+    try:
+        from ...context.java_context import extract_java_models as _jv
+        jv = _jv
+    except Exception:
+        pass
+    return py, jv
+
+
+def _is_model_path(rel: Path) -> bool:
+    parts = [p.lower() for p in rel.parts]
+    if "src" in parts and "test" in parts:
+        return False
+    if any(part in SKIP_DIRS for part in parts):
+        return False
+    stem = rel.stem
+    if any(stem.endswith(s) for s in SKIP_SUFFIXES):
+        return False
+    return any(part in MODEL_DIRS for part in parts)
+
+
+def _has_entity_annotation(path: Path) -> bool:
+    """Fast check: does this .java file contain a JPA/document annotation?"""
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+        for ann in _ENTITY_ANNOTATIONS:
+            if f"@{ann}" in text:
+                return True
+    except Exception:
+        pass
+    return False
+
+
+def register_models(app: typer.Typer) -> None:
+    @app.command(help="List domain models.")
+    def models(
+        root: str = typer.Argument(".", help="Project root folder"),
+        all_files: bool = typer.Option(False, "--all", help="Scan all Java files (not just model dirs)"),
+        with_inherited: bool = typer.Option(True, "--inherited/--no-inherited", help="Merge inherited fields"),
+    ):
+        root_path = Path(root).resolve()
+        project_root = find_project_root(root_path)
+        extract_python_models, extract_java_models = _import_extractors()
+        files = find_all_supported_files(project_root)
+
+        pr = project_root.resolve()
+        candidates: list[Path] = []
+
+        for f in files:
+            fr = f.resolve()
+            try:
+                rel = fr.relative_to(pr)
+            except Exception:
+                continue
+
+            ext = f.suffix.lower()
+
+            if ext == ".py":
+                if _is_model_path(rel):
+                    candidates.append(fr)
+            elif ext == ".java":
+                # 1. Directory-based heuristic
+                if all_files or _is_model_path(rel):
+                    candidates.append(fr)
+                # 2. Annotation-based fallback — catches petclinic-style feature packages
+                elif _has_entity_annotation(fr):
+                    candidates.append(fr)
+
+        # --- collect all java models first for inheritance resolution ---
+        from ...lang.java.models import resolve_inherited_fields, ModelDef
+
+        java_models_all: list[ModelDef] = []
+        java_file_map: dict[str, list[ModelDef]] = {}
+
+        if extract_java_models:
+            for f in sorted(candidates, key=lambda x: str(x).lower()):
+                if f.suffix.lower() == ".java":
+                    defs = extract_java_models(f, pr)
+                    java_file_map[str(f)] = defs
+                    java_models_all.extend(defs)
+
+            if with_inherited:
+                java_models_all = resolve_inherited_fields(java_models_all)
+                # rebuild map with resolved models
+                resolved_by_name = {m.name: m for m in java_models_all}
+                for k in java_file_map:
+                    java_file_map[k] = [
+                        resolved_by_name.get(m.name, m)
+                        for m in java_file_map[k]
+                    ]
+
+        out: list[str] = []
+        for f in sorted(candidates, key=lambda x: str(x).lower()):
+            ext = f.suffix.lower()
+            if ext == ".py" and extract_python_models is not None:
+                defs = extract_python_models(f, project_root)
+            elif ext == ".java":
+                defs = java_file_map.get(str(f), [])
+            else:
+                continue
+            for d in defs:
+                inherited_marker = f"  [extends: {', '.join(d.bases)}]" if d.bases else ""
+                out.append(f"{d.name}  ({d.kind}){inherited_marker}  {d.file}")
+                for fld in d.fields:
+                    out.append(f"  - {fld.name}: {fld.type}")
+
+        if not out:
+            typer.echo("No domain models found.")
+            raise typer.Exit(0)
+
+        for line in out:
+            typer.echo(line)