aja-codeintel 0.1.0__py3-none-any.whl

codeintel_cli/core/resolve_model_target.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+from pathlib import Path
+import typer
+
+from ..errors import InvalidPathError
+from .project import find_project_root
+from .fuzzy import rank_paths, fuzzy_is_confident
+from ..scanner.scanner import find_all_supported_files
+
+def _is_domain_model_path(p: Path) -> bool:
+    parts = {x.lower() for x in p.parts}
+    return bool(parts & {"model", "models", "entity", "entities", "domain"})
+
+def _java_model_annotation_hint(path: Path) -> bool:
+    try:
+        t = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return False
+    return any(x in t for x in ("@Entity", "@Table", "@Embeddable", "@MappedSuperclass"))
+
+def _has_class_definition(path: Path) -> bool:
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+        return "class " in text and len(text.strip()) > 50
+    except Exception:
+        return False
+
+def _is_java_model_file(p: Path) -> bool:
+    if p.suffix.lower() != ".java":
+        return False
+    if p.name == "__init__.py":
+        return False
+    if not (_is_domain_model_path(p) or _java_model_annotation_hint(p)):
+        return False
+    return _has_class_definition(p)
+
+def _is_python_model_file(p: Path) -> bool:
+    if p.suffix.lower() != ".py":
+        return False
+    if p.name in {"__init__.py", "models.py"}:
+        return False
+    if not _is_domain_model_path(p):
+        return False
+    return _has_class_definition(p)
+
+def resolve_model_target_file(query: str, root: str = ".", top: int = 3) -> tuple[Path, Path]:
+    root_path = Path(root).resolve()
+    project_root = find_project_root(root_path)
+    
+    q = Path(query)
+    if q.exists() and q.is_file():
+        return q.resolve(), project_root
+    
+    files = find_all_supported_files(project_root)
+    model_files: list[Path] = [p for p in files if _is_java_model_file(p) or _is_python_model_file(p)]
+    
+    if not model_files:
+        raise InvalidPathError(message="No model/entity files found", path=project_root)
+    
+    qstem_lower = Path(query).stem.lower()
+    exact_matches = [f for f in model_files if f.stem.lower() == qstem_lower]
+    
+    if len(exact_matches) == 1:
+        return exact_matches[0].resolve(), project_root
+    
+    if len(exact_matches) > 1:
+        exact_matches = exact_matches[:top]
+    
+    ranked = rank_paths(query, exact_matches if exact_matches else model_files, project_root, top=top)
+    
+    if not ranked:
+        raise InvalidPathError(message="Model not found", path=Path(query))
+    
+    if fuzzy_is_confident(ranked):
+        top_score = ranked[0][1]
+        ties = [x for x in ranked if abs(x[1] - top_score) < 0.02]
+        if len(ties) == 1:
+            return ranked[0][0].resolve(), project_root
+    
+    typer.echo("Select model:")
+    for i, (p, score) in enumerate(ranked, 1):
+        try:
+            rel = p.relative_to(project_root)
+        except Exception:
+            rel = p
+        typer.echo(f"{i}. {rel.as_posix()}   score={score:.2f}")
+    
+    choice = typer.prompt("Select number (0=cancel)", type=int, default=0)
+    if choice == 0 or choice < 1 or choice > len(ranked):
+        raise typer.Exit()
+    
+    return ranked[choice - 1][0].resolve(), project_root

codeintel_cli/core/resolve_target.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+from pathlib import Path
+import typer
+
+from ..errors import InvalidPathError
+from .project import find_project_root
+from .fuzzy import rank_paths, fuzzy_is_confident
+from ..scanner.scanner import find_all_supported_files
+
+
+def resolve_target_file(query: str, root: str = ".", top: int = 3) -> tuple[Path, Path]:
+    root_path = Path(root).resolve()
+    project_root = find_project_root(root_path)
+
+    q = Path(query)
+    if q.exists() and q.is_file():
+        return q.resolve(), project_root
+
+    all_files = find_all_supported_files(project_root)
+
+    qstem_lower = Path(query).stem.lower()
+    exact_matches = [f for f in all_files if f.stem.lower() == qstem_lower and f.name != "__init__.py"]
+
+    if len(exact_matches) == 1:
+        return exact_matches[0].resolve(), project_root
+
+    if len(exact_matches) > 1:
+        exact_matches = exact_matches[:top]
+
+    ranked = rank_paths(query, all_files if not exact_matches else exact_matches, project_root, top=top)
+
+    if not ranked:
+        raise InvalidPathError(message="File not found", path=Path(query))
+
+    if fuzzy_is_confident(ranked):
+        top_score = ranked[0][1]
+        ties = [x for x in ranked if abs(x[1] - top_score) < 0.02]
+        if len(ties) == 1:
+            return ranked[0][0].resolve(), project_root
+
+    typer.echo("Did you mean:")
+    for i, (p, score) in enumerate(ranked, 1):
+        try:
+            rel = p.relative_to(project_root)
+        except Exception:
+            rel = p
+        typer.echo(f"{i}. {rel.as_posix()}   score={score:.2f}")
+
+    choice = typer.prompt("Select number (0=cancel)", type=int, default=0)
+    if choice == 0 or choice < 1 or choice > len(ranked):
+        raise typer.Exit()
+
+    return ranked[choice - 1][0].resolve(), project_root

codeintel_cli/core/timing.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import time
+import typer
+
+
+def start_timer() -> float:
+    return time.perf_counter()
+
+
+def end_timer(t0: float) -> None:
+    dt = time.perf_counter() - t0
+    typer.echo(f"Finished in {dt:.3f}s")

codeintel_cli/core/where.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def _py_file_to_module(path: Path, root: Path) -> str | None:
+    if path.suffix.lower() != ".py":
+        return None
+    try:
+        rel = path.resolve().relative_to(root.resolve())
+    except Exception:
+        return None
+    parts = list(rel.parts)
+    if not parts:
+        return None
+    if parts[-1] == "__init__.py":
+        parts = parts[:-1]
+    else:
+        parts[-1] = Path(parts[-1]).stem
+    if not parts:
+        return None
+    return ".".join(parts)
+
+
+def _java_file_to_module(path: Path, root: Path) -> str | None:
+    if path.suffix.lower() != ".java":
+        return None
+
+    p = path.resolve()
+    try:
+        rel = p.relative_to(root.resolve())
+    except Exception:
+        rel = p
+
+    parts = list(rel.parts)
+    if not parts:
+        return None
+
+    low = [x.lower() for x in parts]
+
+    def build_from(start_idx: int) -> str | None:
+        if start_idx >= len(parts):
+            return None
+        segs = parts[start_idx:]
+        if not segs:
+            return None
+        last = Path(segs[-1]).stem
+        segs = list(segs[:-1]) + [last]
+        segs = [s for s in segs if s and s not in (".", "..")]
+        if not segs:
+            return None
+        return ".".join(segs)
+
+    if "src" in low:
+        i = low.index("src")
+        if i + 3 < len(parts) and low[i + 1] in ("main", "test") and low[i + 2] == "java":
+            out = build_from(i + 3)
+            if out:
+                return out
+
+    if "java" in low:
+        i = low.index("java")
+        out = build_from(i + 1)
+        if out:
+            return out
+
+    if "com" in low:
+        i = low.index("com")
+        out = build_from(i)
+        if out:
+            return out
+
+    return None
+
+
+def file_to_module(path: Path, root: Path) -> str | None:
+    return _py_file_to_module(path, root) or _java_file_to_module(path, root)

codeintel_cli/db/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .cache import get_cache, CacheManager
+from .schema import init_db, get_db_path
+from .operations import needs_rescan
+
+__all__ = ["get_cache", "CacheManager", "init_db", "get_db_path", "needs_rescan"]

codeintel_cli/db/cache.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from .schema import init_db, get_db_path
+from .operations import (
+    is_file_cached,
+    upsert_file,
+    clear_file_data,
+    insert_import,
+    insert_symbol,
+    insert_model,
+    get_all_files,
+    get_file_id,
+    get_file_imports,
+    get_file_symbols,
+    get_models,
+    needs_rescan,
+    get_imports_map_for_paths,
+    get_all_file_id_map,
+    get_unresolved_import_rows,
+    get_file_path_and_lang,
+    update_import_resolved,
+)
+from ..scanner.scanner import find_all_supported_files
+
+
+def _encode_py_import(mod: str, level: int) -> str:
+    mod = (mod or "").strip()
+    level = int(level or 0)
+    if level <= 0:
+        return mod
+    return ("." * level) + mod
+
+
+class CacheManager:
+    def __init__(self, project_root: Path):
+        self.project_root = project_root.resolve()
+        self.db_path = get_db_path(self.project_root)
+        self.conn: sqlite3.Connection | None = None
+
+    def __enter__(self):
+        self.conn = init_db(self.db_path)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not self.conn:
+            return
+        if exc_type is None:
+            self.conn.commit()
+        else:
+            self.conn.rollback()
+        self.conn.close()
+
+    def needs_rescan(self) -> bool:
+        if not self.conn:
+            return True
+        return needs_rescan(self.conn, self.project_root)
+
+    def scan_project(self, verbose: bool = False) -> int:
+        if not self.conn:
+            raise RuntimeError("CacheManager not initialized")
+
+        files = find_all_supported_files(self.project_root)
+        scanned = 0
+
+        for file_path in files:
+            file_path = file_path.resolve()
+            if is_file_cached(self.conn, file_path):
+                continue
+
+            try:
+                content = file_path.read_text(encoding="utf-8", errors="ignore")
+            except Exception:
+                content = ""
+
+            try:
+                rel_path = str(file_path.relative_to(self.project_root))
+            except Exception:
+                rel_path = str(file_path)
+
+            language = file_path.suffix.lstrip(".").lower()
+            file_id = upsert_file(self.conn, file_path, rel_path, language, content)
+
+            clear_file_data(self.conn, file_id)
+            self._index_file(file_id, file_path, content, language)
+
+            scanned += 1
+            if verbose and scanned % 10 == 0:
+                print(f"Indexed {scanned} files...")
+
+        self._resolve_import_edges()
+        self.conn.commit()
+        return scanned
+
+    def _index_file(self, file_id: int, file_path: Path, content: str, language: str) -> None:
+        if language == "py":
+            self._index_python_file(file_id, file_path, content)
+        elif language == "java":
+            self._index_java_file(file_id, file_path, content)
+
+    def _index_python_file(self, file_id: int, file_path: Path, content: str) -> None:
+        import ast
+
+        try:
+            tree = ast.parse(content)
+        except Exception:
+            return
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    if alias.name:
+                        insert_import(self.conn, file_id, alias.name, None)
+            elif isinstance(node, ast.ImportFrom):
+                mod = node.module or ""
+                lvl = int(getattr(node, "level", 0) or 0)
+                insert_import(self.conn, file_id, _encode_py_import(mod, lvl), None)
+            elif isinstance(node, ast.ClassDef):
+                insert_symbol(self.conn, file_id, node.name, "class", getattr(node, "lineno", 1))
+            elif isinstance(node, ast.FunctionDef):
+                insert_symbol(self.conn, file_id, node.name, "function", getattr(node, "lineno", 1))
+
+        try:
+            from ..lang.router import extract_models_for_file
+
+            models = extract_models_for_file(file_path, self.project_root)
+            for model in models or []:
+                fields = [(f.name, f.type, f.name.lower() == "id") for f in (model.fields or [])]
+                insert_model(self.conn, file_id, model.name, fields, [])
+        except Exception:
+            pass
+
+    def _index_java_file(self, file_id: int, file_path: Path, content: str) -> None:
+        import re
+
+        for m in re.finditer(r"import\s+([\w.]+)\s*;", content):
+            imp = (m.group(1) or "").strip()
+            if imp:
+                insert_import(self.conn, file_id, imp, None)
+
+        for m in re.finditer(r"\b(class|interface|enum|record)\s+([A-Za-z_]\w*)", content):
+            insert_symbol(self.conn, file_id, m.group(2), m.group(1), None)
+
+        try:
+            from ..context.java_rel import java_fields_and_rels
+
+            fields, rels = java_fields_and_rels(file_path)
+            if fields:
+                relationships = [{"kind": r.kind, "target": r.target, "field": r.field} for r in rels]
+                insert_model(self.conn, file_id, file_path.stem, fields, relationships)
+        except Exception:
+            pass
+
+    def _resolve_import_edges(self) -> None:
+        if not self.conn:
+            return
+
+        from ..parser.resolve import resolve_import_to_file
+        from ..lang.java.resolve import resolve_java_import_to_file
+
+        file_id_by_path = get_all_file_id_map(self.conn)
+        rows = get_unresolved_import_rows(self.conn)
+
+        for imp_row_id, src_file_id, imp in rows:
+            meta = get_file_path_and_lang(self.conn, src_file_id)
+            if not meta:
+                continue
+            src_path_str, lang = meta
+            src_path = Path(src_path_str)
+
+            target: Path | None = None
+
+            if lang == "py":
+                s = (imp or "").strip()
+                if not s:
+                    continue
+                level = 0
+                while level < len(s) and s[level] == ".":
+                    level += 1
+                mod = s[level:] if level > 0 else s
+                target = resolve_import_to_file(mod, level, src_path, self.project_root)
+
+            elif lang == "java":
+                s = (imp or "").strip()
+                if not s or s.endswith(".*"):
+                    continue
+                target = resolve_java_import_to_file(s, self.project_root)
+
+            if not target:
+                continue
+
+            tid = file_id_by_path.get(str(target.resolve()))
+            if tid:
+                update_import_resolved(self.conn, imp_row_id, tid)
+
+    def get_cached_files(self) -> list[Path]:
+        if not self.conn:
+            return []
+        return get_all_files(self.conn)
+
+    def get_file_data(self, file_path: Path) -> dict[str, Any]:
+        if not self.conn:
+            return {}
+        file_id = get_file_id(self.conn, file_path)
+        if not file_id:
+            return {}
+        return {"imports": get_file_imports(self.conn, file_id), "symbols": get_file_symbols(self.conn, file_id)}
+
+    def get_all_models(self) -> list[dict]:
+        if not self.conn:
+            return []
+        return get_models(self.conn)
+
+    def get_imports_map(self, files: list[Path]) -> dict[str, list[str]]:
+        if not self.conn:
+            return {}
+        return get_imports_map_for_paths(self.conn, files)
+
+
+def get_cache(project_root: Path) -> CacheManager:
+    return CacheManager(project_root)