aja-codeintel 0.1.0__py3-none-any.whl

codeintel_cli/context/java_rel.py

@@ -0,0 +1,299 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import re
+
+
+@dataclass(frozen=True)
+class Rel:
+    kind: str
+    target: str
+    field: str
+    cascade: str | None = None
+    fetch: str | None = None
+    mapped_by: str | None = None
+    join_table: str | None = None
+    join_columns: list[str] | None = None
+
+
+_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*(?:public|protected|private)?\s*(?:static\s+)?(?:final\s+)?([A-Za-z0-9_<>\[\].,?]+)\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:=.*)?;"
+)
+_REL_ANNOS = {"OneToOne", "OneToMany", "ManyToMany", "ManyToOne"}
+_ANN_START_RE = re.compile(r"^\s*@([A-Za-z_][A-Za-z0-9_]*)\b(.*)$")
+_JOINCOL_NAME_RE = re.compile(r'name\s*=\s*"([^"]+)"')
+_QUOTED_RE = re.compile(r'^["\'](.*)["\']$')
+
+_DENY_FIELD_NAMES = {"return", "this", "true", "false", "null", "new", "super", "throw"}
+_DENY_FIELD_TYPES = {"return", "throw"}
+
+
+def clean_java(text: str) -> str:
+    if not text:
+        return ""
+    text = re.sub(r"/\*.*?\*/", "", text, flags=re.S)
+    text = re.sub(r"//.*?$", "", text, flags=re.M)
+    return text
+
+
+def top_type_name(text: str, fallback: str) -> str:
+    if not text:
+        return fallback
+    m = _TYPE_RE.search(text)
+    return m.group(2) if m else fallback
+
+
+def _collapse_annotations(text: str) -> str:
+    lines = text.splitlines()
+    result: list[str] = []
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        stripped = line.strip()
+        if stripped.startswith("@"):
+            depth = stripped.count("(") - stripped.count(")")
+            combined = stripped
+            j = i + 1
+            while depth > 0 and j < len(lines):
+                nxt = lines[j].strip()
+                combined = combined + " " + nxt
+                depth += nxt.count("(") - nxt.count(")")
+                j += 1
+            result.append(combined)
+            i = j
+        else:
+            result.append(line)
+            i += 1
+    return "\n".join(result)
+
+
+def _split_record_params(sig: str) -> list[tuple[str, str]]:
+    s = (sig or "").strip()
+    if not s:
+        return []
+    parts: list[str] = []
+    cur: list[str] = []
+    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 _strip_quotes(v: str | None) -> str | None:
+    if not v:
+        return None
+    s = v.strip()
+    m = _QUOTED_RE.match(s)
+    if m:
+        s = m.group(1).strip()
+    return s or None
+
+
+def _extract_arg_map(argstr: str) -> dict[str, str]:
+    s = (argstr or "").strip()
+    if not s:
+        return {}
+    out: dict[str, str] = {}
+    cur: list[str] = []
+    parts: list[str] = []
+    depth = 0
+    for ch in s:
+        if ch == "(":
+            depth += 1
+        elif ch == ")":
+            depth = max(0, depth - 1)
+        if ch == "," and depth == 0:
+            parts.append("".join(cur).strip())
+            cur = []
+            continue
+        cur.append(ch)
+    if cur:
+        parts.append("".join(cur).strip())
+
+    for p in parts:
+        if not p:
+            continue
+        if "=" in p:
+            k, v = p.split("=", 1)
+            out[k.strip()] = v.strip()
+        else:
+            out["value"] = p.strip()
+    return out
+
+
+def _unwrap_java_type(t: str) -> str:
+    s = (t or "").strip()
+    if not s:
+        return ""
+    s = s.replace("java.util.", "")
+    s = s.replace("javax.persistence.", "")
+    s = s.replace("jakarta.persistence.", "")
+
+    m_opt = re.match(r"^Optional\s*<\s*([^>]+)\s*>$", s)
+    if m_opt:
+        s = m_opt.group(1).strip()
+
+    m_col = re.match(r"^(List|Set|Collection|Iterable)\s*<\s*([^>]+)\s*>$", s)
+    if m_col:
+        s = m_col.group(2).strip()
+
+    if "." in s:
+        s = s.split(".")[-1].strip()
+
+    return s
+
+
+def java_fields_and_rels(path: Path) -> tuple[list[tuple[str, str, bool]], list[Rel]]:
+    try:
+        raw = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return [], []
+
+    text = clean_java(raw)
+    if not text:
+        return [], []
+
+    mrec = _RECORD_RE.search(text)
+    if mrec:
+        params = mrec.group(2)
+        flds = [(n, t, n.lower() == "id") for (n, t) in _split_record_params(params)]
+        return flds, []
+
+    text = _collapse_annotations(text)
+
+    lines = text.splitlines()
+    fields: list[tuple[str, str, bool]] = []
+    rels: list[Rel] = []
+    pending: list[tuple[str, dict[str, str], str]] = []
+    pending_is_id = False
+
+    for line in lines:
+        s = line.strip()
+        if not s:
+            continue
+
+        m = _ANN_START_RE.match(s)
+        if m:
+            name = m.group(1)
+            rest = m.group(2).strip()
+            full = rest
+            if full.startswith("(") and full.endswith(")"):
+                full = full[1:-1].strip()
+            args = _extract_arg_map(full)
+            if name == "Id":
+                pending_is_id = True
+            if name in _REL_ANNOS or name in {"JoinTable", "JoinColumn", "JoinColumns"}:
+                pending.append((name, args, s))
+            continue
+
+        fm = _FIELD_RE.match(line)
+        if not fm:
+            pending.clear()
+            pending_is_id = False
+            continue
+
+        ftype = fm.group(1).strip()
+        fname = fm.group(2).strip()
+
+        if not fname or fname.lower() in _DENY_FIELD_NAMES:
+            pending.clear()
+            pending_is_id = False
+            continue
+        if ftype.lower() in _DENY_FIELD_TYPES:
+            pending.clear()
+            pending_is_id = False
+            continue
+
+        is_pk = pending_is_id or fname.lower() == "id"
+        fields.append((fname, ftype, is_pk))
+
+        rel_kind: str | None = None
+        rel_args: dict[str, str] = {}
+        join_table: str | None = None
+        join_cols: list[str] = []
+
+        for aname, aargs, raw_line in pending:
+            if aname in _REL_ANNOS:
+                rel_kind = aname
+                rel_args = aargs
+            elif aname == "JoinTable":
+                join_table = _strip_quotes(aargs.get("name") or aargs.get("value"))
+                if not join_table:
+                    mm = re.search(r'name\s*=\s*"([^"]+)"', raw_line)
+                    if mm:
+                        join_table = mm.group(1).strip()
+            elif aname in {"JoinColumn", "JoinColumns"}:
+                for mm in _JOINCOL_NAME_RE.finditer(raw_line):
+                    join_cols.append(mm.group(1).strip())
+
+        if rel_kind:
+            target = _unwrap_java_type(ftype)
+            if target:
+                rels.append(
+                    Rel(
+                        kind=rel_kind,
+                        target=target,
+                        field=fname,
+                        cascade=_strip_quotes(rel_args.get("cascade")),
+                        fetch=_strip_quotes(rel_args.get("fetch")),
+                        mapped_by=_strip_quotes(rel_args.get("mappedBy")),
+                        join_table=join_table,
+                        join_columns=join_cols or None,
+                    )
+                )
+
+        pending.clear()
+        pending_is_id = False
+
+    return fields, rels
+
+
+def model_fields_from_extractor(path: Path, project_root: Path) -> list[tuple[str, str, bool]]:
+    try:
+        from ..lang.router import extract_models_for_file
+
+        defs = extract_models_for_file(path, project_root)
+        if not defs:
+            return []
+
+        d0 = defs[0]
+        out: list[tuple[str, str, bool]] = []
+
+        for f in getattr(d0, "fields", []) or []:
+            name = (getattr(f, "name", "") or "").strip()
+            typ = (getattr(f, "type", "") or "").strip() or "Object"
+
+            if not name:
+                continue
+            if name.lower() in _DENY_FIELD_NAMES:
+                continue
+            if typ.lower() in _DENY_FIELD_TYPES:
+                continue
+
+            out.append((name, typ, name.lower() == "id"))
+
+        return out
+    except Exception:
+        return []

codeintel_cli/context/java_service.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+from pathlib import Path
+import re
+from typing import Any
+
+from ..scanner.scanner import find_all_supported_files
+from ..context.java_rel import clean_java, top_type_name, java_fields_and_rels
+
+_METHOD_RE = re.compile(
+    r"^\s*(?:public|protected|private)?\s+(?:static\s+)?"
+    r"([A-Za-z0-9_<>\[\].,?\s]+?)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)",
+    re.M,
+)
+_FIELD_RE = re.compile(
+    r"^\s*(?:private|protected)\s+(?:final\s+)?"
+    r"([A-Za-z0-9_<>,\s]+?)\s+([A-Za-z_][A-Za-z0-9_]*)\s*;",
+    re.M,
+)
+_MAPPING_RE = re.compile(
+    r"@(Get|Post|Put|Delete|Patch|Request)Mapping"
+    r"(?:"
+    r"\(\s*(?:value|path)\s*=\s*[\"']([^\"']*)[\"'][^)]*\)"  # named: value="/path"
+    r"|\(\s*[\"']([^\"']*)[\"']\s*\)"                         # positional: "/path"
+    r"|\(\s*\)"                                                # empty parens: ()
+    r"|(?=\s|$|@|\n)"                                         # bare: no parens at all
+    r")",
+    re.M,
+)
+_CLASS_MAPPING_RE = re.compile(
+    r'@RequestMapping\s*\(\s*(?:value\s*=\s*|path\s*=\s*)?["\']([^"\']*)["\']'
+)
+_CLASS_NAME_RE = re.compile(r"\bclass\s+([A-Za-z_][A-Za-z0-9_]*)\b")
+
+_SKIP_TYPES   = {"void", "public", "private", "protected", "static", "final"}
+_SKIP_METHODS = {"equals", "hashCode", "toString", "clone"}
+_PRIMITIVES   = {"String", "Long", "Integer", "Boolean", "List", "Set", "Optional", "Page", "Object"}
+
+_DEFAULT_REPO_METHODS = [
+    "findById(ID) → Optional<T>",
+    "save(T) → T",
+    "findAll() → List<T>",
+    "deleteById(ID)",
+    "existsById(ID) → boolean",
+]
+
+
+def _extract_type_name(full_type: str) -> str:
+    s = (full_type or "").strip()
+    s = s.replace("java.util.", "").replace("org.springframework.", "")
+    if "." in s:
+        s = re.sub(r"\b\w+\.", "", s)
+    return s
+
+
+def _find_service_impl(service_file: Path, project_root: Path) -> Path | None:
+    impl_name = service_file.stem + "Impl"
+    for f in find_all_supported_files(project_root):
+        if f.stem == impl_name and f.suffix.lower() == ".java":
+            return f
+    return None
+
+
+def _find_controllers(project_root: Path, service_name: str) -> list[dict]:
+    endpoints: list[dict] = []
+    seen: set[tuple[str, str]] = set()
+
+    for f in find_all_supported_files(project_root):
+        if f.suffix.lower() != ".java":
+            continue
+        if "controller" not in {p.lower() for p in f.parts}:
+            continue
+
+        try:
+            text = clean_java(f.read_text(encoding="utf-8", errors="ignore"))
+        except OSError:
+            continue
+
+        if service_name not in text:
+            continue
+
+        m = _CLASS_NAME_RE.search(text)
+        controller_class = m.group(1) if m else ""
+        camel_class = controller_class[0].lower() + controller_class[1:] if controller_class else ""
+
+        class_mapping = ""
+        cm = _CLASS_MAPPING_RE.search(text)
+        if cm:
+            class_mapping = cm.group(1).rstrip("/")
+
+        for mm in _MAPPING_RE.finditer(text):
+            verb = mm.group(1)
+            if not verb:
+                continue
+
+            verb = verb.upper()
+            if verb == "REQUEST":
+                continue  # @RequestMapping on class level — skip, already handled via class_mapping
+
+            raw_path = mm.group(2) or mm.group(3) or ""
+            if class_mapping:
+                full_path = class_mapping if not raw_path else class_mapping + "/" + raw_path.lstrip("/")
+            else:
+                full_path = raw_path or "/"
+            full_path = re.sub(r"/+", "/", full_path)
+
+            next_chunk = text[mm.end(): mm.end() + 400]
+            handler_match = re.search(
+                r"(?:public|protected|private)[^(]*\s+([a-z][A-Za-z0-9_]*)\s*\(",
+                next_chunk,
+            ) or re.search(r"\s+([a-z][A-Za-z0-9_]*)\s*\(", next_chunk)
+
+            if not handler_match:
+                continue
+
+            handler_name = handler_match.group(1)
+            if handler_name in {controller_class, camel_class}:
+                continue
+
+            key = (verb, full_path)
+            if key in seen:
+                continue
+            seen.add(key)
+
+            endpoints.append({
+                "method": verb,
+                "path": full_path,
+                "handler": f"{f.stem}.{handler_name}()",
+            })
+
+    return endpoints
+
+
+def _find_models_used(text: str, project_root: Path) -> dict[str, Any]:
+    model_names: set[str] = set()
+
+    for match in re.finditer(r"import\s+[\w.]+\.(?:entity|model|domain)\.([A-Z]\w+);", text):
+        model_names.add(match.group(1))
+
+    for match in re.finditer(r"\b([A-Z][A-Za-z0-9_]+)\s+\w+\s*[;=]", text):
+        name = match.group(1)
+        if len(name) > 2 and not name.isupper() and name not in _PRIMITIVES:
+            model_names.add(name)
+
+    models: dict[str, Any] = {}
+    entity_dirs = {"model", "models", "entity", "entities", "domain"}
+
+    for model_name in model_names:
+        for f in find_all_supported_files(project_root):
+            if f.suffix.lower() != ".java" or f.stem != model_name:
+                continue
+            if not ({p.lower() for p in f.parts} & entity_dirs):
+                continue
+            try:
+                fields, rels = java_fields_and_rels(f)
+                if fields:
+                    models[model_name] = {
+                        "fields": fields,
+                        "relationships": [
+                            {"kind": r.kind, "target": r.target, "field": r.field}
+                            for r in rels
+                        ],
+                    }
+            except Exception:
+                pass
+
+    return models
+
+
+def _find_repositories(text: str) -> list[dict]:
+    repos: list[dict] = []
+
+    for match in _FIELD_RE.finditer(text):
+        ftype, fname = match.group(1), match.group(2)
+        if "Repository" in ftype or "repository" in fname.lower():
+            repo_name = _extract_type_name(ftype)
+            if not any(r["name"] == repo_name for r in repos):
+                repos.append({"name": repo_name, "methods": _DEFAULT_REPO_METHODS})
+
+    for match in re.finditer(r"import\s+[\w.]+\.repository\.([A-Z]\w+Repository);", text):
+        repo_name = match.group(1)
+        if not any(r["name"] == repo_name for r in repos):
+            repos.append({"name": repo_name, "methods": _DEFAULT_REPO_METHODS})
+
+    return repos
+
+
+def _extract_service_methods(text: str, class_name: str = "") -> list[dict]:
+    methods: list[dict] = []
+    seen_names: set[str] = set()
+
+    for match in _METHOD_RE.finditer(text):
+        raw_ret     = match.group(1).strip()
+        method_name = match.group(2)
+        params      = match.group(3).strip()
+
+        if method_name in seen_names:
+            continue
+        if class_name and method_name == class_name:
+            continue
+        if method_name in _SKIP_METHODS:
+            continue
+        if method_name.startswith("set") and params:
+            continue
+        if method_name.startswith("get") and method_name.endswith("Service"):
+            continue
+
+        ret_type = _extract_type_name(raw_ret)
+        if ret_type in _SKIP_TYPES:
+            continue
+
+        param_list: list[str] = []
+        for p in params.split(","):
+            p = p.strip()
+            if not p:
+                continue
+            tokens = p.split()
+            if len(tokens) >= 2:
+                ptype = _extract_type_name(" ".join(tokens[:-1]))
+                param_list.append(f"{ptype} {tokens[-1]}")
+
+        seen_names.add(method_name)
+        methods.append({
+            "name":   method_name,
+            "params": ", ".join(param_list),
+            "return": ret_type if ret_type not in _SKIP_TYPES else "",
+        })
+
+    return methods
+
+
+def analyze_java_service(service_file: Path, project_root: Path) -> dict:
+    try:
+        text = clean_java(service_file.read_text(encoding="utf-8", errors="ignore"))
+    except OSError:
+        text = ""
+
+    service_name = top_type_name(text, service_file.stem)
+
+    impl_text = text
+    if "interface " in text:
+        impl_file = _find_service_impl(service_file, project_root)
+        if impl_file:
+            try:
+                impl_text = clean_java(impl_file.read_text(encoding="utf-8", errors="ignore"))
+            except OSError:
+                pass
+
+    endpoints = _find_controllers(project_root, service_name)
+    methods   = _extract_service_methods(text, service_name)
+    models    = _find_models_used(impl_text, project_root)
+    repos     = _find_repositories(impl_text)
+
+    flow: list[str] = []
+    if endpoints:
+        ep = endpoints[0]
+        flow.append(f"{ep['method']} {ep['path']}")
+        flow.append("  ↓")
+        flow.append(f"{ep['handler']}")
+        flow.append("  ↓")
+        if methods:
+            m0  = methods[0]
+            arg = m0["params"].split(",")[0].split()[-1] if m0["params"] else ""
+            flow.append(f"{service_name}.{m0['name']}({arg + '...' if arg else ''})")
+            flow.append("  ↓")
+        if models:
+            model_name = next(iter(models))
+            flow.append(f"Uses {model_name} model")
+            if models[model_name].get("relationships"):
+                rel = models[model_name]["relationships"][0]
+                flow.append(f"  (has {rel['kind']} → {rel['target']})")
+            flow.append("  ↓")
+        if repos:
+            flow.append(f"{repos[0]['name']}.save()")
+            flow.append("  ↓")
+            if methods and methods[0].get("return"):
+                flow.append(f"Returns: {methods[0]['return']}")
+
+    return {
+        "service_name": service_name,
+        "endpoints":    endpoints,
+        "methods":      methods,
+        "models":       models,
+        "repositories": repos,
+        "flow":         flow,
+        "summary": {
+            "Endpoints":       len(endpoints),
+            "Service methods": len(methods),
+            "Models used":     len(models),
+            "Repositories":    len(repos),
+        },
+    }

codeintel_cli/context/python_context.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pathlib import Path
+import typer
+
+from ..graph.builder import build_graph_with_counts, get_hub_files_by_ratio
+from ..graph.query import get_related
+from ..parser.symbols import extract_classes_from_file, extract_funcs_from_file
+
+
+def _path_to_module(path: Path, root: Path) -> str:
+    rel = path.relative_to(root)
+    parts = list(rel.parts)
+    if parts and parts[-1] == "__init__.py":
+        parts = parts[:-1]
+    elif parts:
+        parts[-1] = parts[-1][:-3]
+    return ".".join(parts)
+
+
+def _sym_lines_py(f: Path, root: Path, show_line: bool) -> tuple[list[str], set[str]]:
+    out: list[str] = []
+    imports: set[str] = set()
+    mod = _path_to_module(f, root)
+
+    for c in extract_classes_from_file(f):
+        if c.name.startswith("_"):
+            continue
+        out.append(c.name if not show_line else f"{c.name} (line {c.lineno})")
+        imports.add(f"from {mod} import {c.name}")
+
+    for fn in extract_funcs_from_file(f):
+        if fn.name.startswith("_") or fn.name.startswith("register_"):
+            continue
+        out.append(fn.name if not show_line else f"{fn.name} (line {fn.lineno})")
+        imports.add(f"from {mod} import {fn.name}")
+
+    return sorted(out), imports
+
+
+def run_python_context(
+    *,
+    target: Path,
+    root: Path,
+    all_files: list[Path],
+    depth: int,
+    forward_only: bool,
+    include_hubs: bool,
+    line: 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)
+
+    scope = get_related(graph, target, depth, include_reverse=not forward_only, hubs=hubs)
+    scope_files = sorted((scope - {target}))
+
+    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("")
+
+    imports_by_file: dict[Path, set[str]] = {}
+
+    typer.echo("RELATED SYMBOLS")
+    if not scope_files:
+        typer.echo("  (none)")
+        typer.echo("")
+        return
+
+    for f in scope_files:
+        lines, imps = _sym_lines_py(f, root, line)
+        if lines:
+            typer.echo(f"• {f.relative_to(root)}")
+            for x in lines:
+                typer.echo(f"   {x}")
+            typer.echo("")
+        if imps:
+            imports_by_file[f] = imps
+
+    typer.echo("IMPORTS")
+    all_imports = sorted({imp for s in imports_by_file.values() for imp in s})
+    if all_imports:
+        for imp in all_imports:
+            typer.echo(f"  {imp}")
+    else:
+        typer.echo("  (none)")
+    typer.echo("")