aja-codeintel 0.1.0__py3-none-any.whl

codeintel_cli/graph/traverse.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pathlib import Path
+from collections import deque
+
+
+def build_reverse_graph(graph: dict[Path, set[Path]]) -> dict[Path, set[Path]]:
+    rev: dict[Path, set[Path]] = {}
+
+    for src, targets in graph.items():
+        rev.setdefault(src, set())
+        for t in targets:
+            rev.setdefault(t, set()).add(src)
+
+    return rev
+
+
+def bfs_related(
+    graph: dict[Path, set[Path]],
+    start: Path,
+    max_depth: int,
+    skip: set[Path] | None = None,
+) -> set[Path]:
+    if max_depth <= 0:
+        return set()
+
+    skip = skip or set()
+    seen: set[Path] = set()
+    q = deque([(start, 0)])
+
+    while q:
+        node, depth = q.popleft()
+
+        expand = node not in skip
+
+        for nxt in graph.get(node, set()):
+            if nxt == start or nxt in seen:
+                continue
+
+            next_depth = depth + 1
+            if next_depth > max_depth:
+                continue
+
+            seen.add(nxt)
+
+            if expand:
+                q.append((nxt, next_depth))
+
+    return seen

codeintel_cli/lang/java/engine.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+IMP = re.compile(r"^\s*import\s+([\w\.]+)\s*;")
+
+
+def java_extract_imports(path: Path):
+    out: list[str] = []
+    try:
+        for line in path.read_text(errors="ignore").splitlines():
+            m = IMP.match(line)
+            if m:
+                out.append(m.group(1))
+    except Exception:
+        pass
+    return out

codeintel_cli/lang/java/models.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import re
+
+
+@dataclass(frozen=True)
+class ModelField:
+    name: str
+    type: str
+
+
+@dataclass(frozen=True)
+class ModelDef:
+    name: str
+    file: str
+    kind: str
+    bases: list[str]
+    fields: list[ModelField]
+
+
+TYPE_RE = re.compile(r"\b(class|interface|enum|record)\s+([A-Za-z_][A-Za-z0-9_]*)\b")
+RECORD_RE = re.compile(r"\brecord\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)")
+FIELD_RE = re.compile(
+    r"^\s*(?:@\w+(?:\([^)]*\))?\s*)*"
+    r"(?:(?:public|protected|private)\s+)?"
+    r"(?:(?:static|final)\s+)*"
+    r"([A-Za-z0-9_<>\[\].,?]+)\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:=.*)?;"
+)
+
+_DENY_TYPES = {"return", "throw", "new", "super", "this", "break", "continue"}
+_DENY_NAMES = {"return", "throw", "new", "super", "this", "true", "false", "null"}
+
+
+def _split_record_params(sig: str) -> list[tuple[str, str]]:
+    s = sig.strip()
+    if not s:
+        return []
+    parts: list[str] = []
+    cur = []
+    depth = 0
+    for ch in s:
+        if ch == "<":
+            depth += 1
+        elif ch == ">":
+            depth = max(0, depth - 1)
+        elif ch == "," and depth == 0:
+            parts.append("".join(cur).strip())
+            cur = []
+            continue
+        cur.append(ch)
+    if cur:
+        parts.append("".join(cur).strip())
+
+    out: list[tuple[str, str]] = []
+    for p in parts:
+        toks = p.split()
+        if len(toks) >= 2:
+            t = " ".join(toks[:-1]).strip()
+            n = toks[-1].strip()
+            if t and n:
+                out.append((n, t))
+    return out
+
+
+def extract_java_models(path: Path, project_root: Path) -> list[ModelDef]:
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return []
+
+    rel = str(path.relative_to(project_root))
+
+    mrec = RECORD_RE.search(text)
+    if mrec:
+        name = mrec.group(1)
+        params = mrec.group(2)
+        fields = [ModelField(n, t) for (n, t) in _split_record_params(params)]
+        return [ModelDef(name, rel, "java", [], fields)]
+
+    mtype = TYPE_RE.search(text)
+    if not mtype:
+        return []
+
+    name = mtype.group(2)
+
+    fields: list[ModelField] = []
+    for line in text.splitlines():
+        s = line.strip()
+        if not s or s.startswith("return ") or s.startswith("throw "):
+            continue
+        fm = FIELD_RE.match(line)
+        if fm:
+            ftype = fm.group(1).strip()
+            fname = fm.group(2).strip()
+            if not ftype or not fname:
+                continue
+            if ftype.lower() in _DENY_TYPES:
+                continue
+            if fname.lower() in _DENY_NAMES:
+                continue
+            fields.append(ModelField(fname, ftype))
+
+    return [ModelDef(name, rel, "java", [], fields)]

codeintel_cli/lang/java/resolve.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def _possible_java_source_roots(project_root: Path) -> list[Path]:
+    out: list[Path] = []
+    seen: set[Path] = set()
+
+    def add(p: Path) -> None:
+        try:
+            pr = p.resolve()
+        except Exception:
+            return
+        if pr in seen:
+            return
+        if pr.exists() and pr.is_dir():
+            seen.add(pr)
+            out.append(pr)
+
+    add(project_root / "src" / "main" / "java")
+    add(project_root / "src" / "test" / "java")
+
+    for p in project_root.rglob("src"):
+        try:
+            if not p.is_dir():
+                continue
+        except Exception:
+            continue
+        add(p / "main" / "java")
+        add(p / "test" / "java")
+
+    add(project_root)
+
+    return out
+
+
+def resolve_java_import_to_file(module: str, project_root: Path) -> Path | None:
+    if not module:
+        return None
+
+    rel = Path(*module.split("."))
+
+    for base in _possible_java_source_roots(project_root):
+        cand = (base / rel).with_suffix(".java")
+        if cand.exists() and cand.is_file():
+            return cand.resolve()
+
+    return None

codeintel_cli/lang/python/engine.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from pathlib import Path
+from ...parser.imports import extract_imports_from_file
+
+
+def py_extract_imports(path: Path):
+    return extract_imports_from_file(path)

codeintel_cli/lang/python/models.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import ast
+
+
+@dataclass(frozen=True)
+class ModelField:
+    name: str
+    type: str
+
+
+@dataclass(frozen=True)
+class ModelDef:
+    name: str
+    file: str
+    kind: str
+    bases: list[str]
+    fields: list[ModelField]
+
+
+def _unparse(node: ast.AST | None) -> str:
+    if node is None:
+        return "Any"
+    try:
+        return ast.unparse(node)
+    except Exception:
+        return node.__class__.__name__
+
+
+def _base_names(cls: ast.ClassDef) -> list[str]:
+    return [_unparse(b) for b in cls.bases]
+
+
+def _has_decorator(cls: ast.ClassDef, name: str) -> bool:
+    for d in cls.decorator_list:
+        if isinstance(d, ast.Name) and d.id == name:
+            return True
+        if isinstance(d, ast.Attribute) and d.attr == name:
+            return True
+    return False
+
+
+def _looks_like_model(cls: ast.ClassDef) -> bool:
+    bases = _base_names(cls)
+    if _has_decorator(cls, "dataclass"):
+        return True
+    if any("BaseModel" in b for b in bases):
+        return True
+    if any(b.endswith("Base") for b in bases):
+        return True
+    return False
+
+
+def extract_python_models(path: Path, project_root: Path) -> list[ModelDef]:
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8", errors="ignore"))
+    except Exception:
+        return []
+
+    rel = str(path.relative_to(project_root))
+    out: list[ModelDef] = []
+
+    for node in tree.body:
+        if not isinstance(node, ast.ClassDef):
+            continue
+        if not _looks_like_model(node):
+            continue
+
+        fields: list[ModelField] = []
+        for st in node.body:
+            if isinstance(st, ast.AnnAssign) and isinstance(st.target, ast.Name):
+                fields.append(ModelField(st.target.id, _unparse(st.annotation)))
+
+        out.append(
+            ModelDef(
+                name=node.name,
+                file=rel,
+                kind="python",
+                bases=_base_names(node),
+                fields=fields,
+            )
+        )
+
+    return out

codeintel_cli/lang/router.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .python.engine import py_extract_imports
+from .java.engine import java_extract_imports
+
+def extract_imports(path: Path, lang: str):
+    path = path.resolve()
+    if lang == "java" or path.suffix.lower() == ".java":
+        return java_extract_imports(path)
+    return py_extract_imports(path)
+
+def extract_models_for_file(path: Path, project_root: Path):
+    path = path.resolve()
+    if path.suffix.lower() == ".py":
+        from .python.models import extract_python_models
+        return extract_python_models(path, project_root)
+
+    if path.suffix.lower() == ".java":
+        from .java.models import extract_java_models
+        return extract_java_models(path, project_root)
+
+    return []

codeintel_cli/parser/imports.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+def extract_imports_from_code(code: str) -> list[tuple[str, int]]:
+    code = code.lstrip("\ufeff")
+    tree = ast.parse(code)
+
+    out: list[tuple[str, int]] = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for n in node.names:
+                if n.name:
+                    out.append((n.name, 0))
+        elif isinstance(node, ast.ImportFrom):
+            out.append((node.module or "", node.level))
+
+    return out
+
+
+def extract_imports_from_file(path: Path) -> list[tuple[str, int]]:
+    text = path.read_text(encoding="utf-8-sig")
+    return extract_imports_from_code(text)

codeintel_cli/parser/resolve.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+from pathlib import Path
+
+
+def resolve_module_to_file(module: str, root: Path) -> Path | None:
+    """
+    Absolute import resolution (backward compatible).
+    Example: 'codeintel_cli.graph.builder' -> root/codeintel_cli/graph/builder.py
+    """
+    if not module:
+        return None
+
+    cand = root / (module.replace(".", "/") + ".py")
+    if cand.exists():
+        return cand.resolve()
+
+    init = root / module.replace(".", "/") / "__init__.py"
+    if init.exists():
+        return init.resolve()
+
+    return None
+
+
+def resolve_import_to_file(module: str, level: int, current_file: Path, root: Path) -> Path | None:
+    """
+    Supports absolute + relative imports.
+    - level=0: absolute import (uses resolve_module_to_file)
+    - level>0: relative import (from . / .. / ...)
+    """
+    # absolute
+    if level == 0:
+        return resolve_module_to_file(module, root)
+
+    # relative
+    base = current_file.parent
+    for _ in range(level - 1):
+        base = base.parent
+
+    target_base = base if module == "" else base / module.replace(".", "/")
+
+    py = target_base.with_suffix(".py")
+    if py.exists():
+        return py.resolve()
+
+    init = target_base / "__init__.py"
+    if init.exists():
+        return init.resolve()
+
+    return None

codeintel_cli/parser/symbols.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import ast
+
+
+@dataclass(frozen=True)
+class ClassInfo:
+    name: str
+    lineno: int
+
+
+@dataclass(frozen=True)
+class FuncInfo:
+    name: str
+    lineno: int
+    signature: str
+
+
+def _format_args(a: ast.arguments) -> str:
+    parts: list[str] = []
+
+    if getattr(a, "posonlyargs", None):
+        for x in a.posonlyargs:
+            parts.append(x.arg)
+        parts.append("/")
+
+    for x in a.args:
+        parts.append(x.arg)
+
+    if a.vararg:
+        parts.append(f"*{a.vararg.arg}")
+    elif a.kwonlyargs:
+        parts.append("*")
+
+    for x in a.kwonlyargs:
+        parts.append(x.arg)
+
+    if a.kwarg:
+        parts.append(f"**{a.kwarg.arg}")
+
+    return ", ".join(parts)
+
+
+def _read_source_text(path: Path) -> str:
+    try:
+        raw = path.read_bytes()
+    except Exception:
+        return ""
+
+    text = raw.decode("utf-8-sig", errors="ignore")
+
+    if "\x00" in text:
+        text = text.replace("\x00", "")
+    if text.startswith("\ufeff"):
+        text = text.lstrip("\ufeff")
+
+    return text
+
+
+def extract_classes_from_file(path: Path) -> list[ClassInfo]:
+    try:
+        text = _read_source_text(path)
+        if not text.strip():
+            return []
+        tree = ast.parse(text)
+    except Exception:
+        return []
+
+    out: list[ClassInfo] = []
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            out.append(ClassInfo(node.name, getattr(node, "lineno", 1)))
+    return out
+
+
+def extract_funcs_from_file(path: Path) -> list[FuncInfo]:
+    try:
+        text = _read_source_text(path)
+        if not text.strip():
+            return []
+        tree = ast.parse(text)
+    except Exception:
+        return []
+
+    out: list[FuncInfo] = []
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef):
+            sig = f"{node.name}({_format_args(node.args)})"
+            out.append(FuncInfo(node.name, getattr(node, "lineno", 1), sig))
+    return out

codeintel_cli/scanner/scanner.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..core.project import is_skipped_path
+
+
+def find_source_files(root: Path, exts: tuple[str, ...]) -> list[Path]:
+    root = root.resolve()
+    results: list[Path] = []
+
+    for ext in exts:
+        for p in root.rglob(f"*{ext}"):
+            if not p.is_file():
+                continue
+            if is_skipped_path(p):
+                continue
+            results.append(p.resolve())
+
+    return sorted(set(results))
+
+
+def find_python_files(root: Path) -> list[Path]:
+    return find_source_files(root, (".py",))
+
+
+def find_java_files(root: Path) -> list[Path]:
+    return find_source_files(root, (".java",))
+
+
+def find_all_supported_files(root: Path) -> list[Path]:
+    root = root.resolve()
+    results: list[Path] = []
+    for p in root.rglob("*"):
+        if not p.is_file():
+            continue
+        if is_skipped_path(p):
+            continue
+        if p.suffix.lower() in {".py", ".java"}:
+            results.append(p.resolve())
+    return sorted(set(results))