aja-codeintel 0.1.0__py3-none-any.whl

codeintel_cli/context/python_rel.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+import ast
+import re
+
+from ..core.project import find_project_root
+from ..scanner.scanner import find_all_supported_files
+from ..lang.router import extract_models_for_file
+
+@dataclass(frozen=True)
+class PyRel:
+    kind: str
+    target: str
+    field: str
+    via: str = ""
+
+_COLLECTION_RE = re.compile(r"^(list|List|set|Set|tuple|Tuple|Sequence)\[(.+)\]$")
+_OPTIONAL_RE = re.compile(r"^(Optional|typing\.Optional)\[(.*)\]$")
+_UNION_RE = re.compile(r"^(Union|typing\.Union)\[(.*)\]$")
+_PEP604_RE = re.compile(r"^(.+)\s*\|\s*None$|^None\s*\|\s*(.+)$")
+_QUOTED_ATOM_RE = re.compile(r'(["\'])([^"\']+)\1')
+_FK_SUFFIXES = ("_id", "Id")
+_EMBED_HINTS = {"address", "profile", "detail", "details", "meta", "metadata", "settings", "config", "configuration"}
+_BUILTIN_TYPES = {
+    "str", "int", "float", "bool", "dict", "list", "tuple", "set", "Any", "None", "object", "bytes", "bytearray",
+    "Decimal", "UUID", "datetime", "date", "time", "timedelta", "Path", "Optional", "Union", "Literal", "TypeVar",
+    "frozenset", "complex", "type", "range", "slice", "memoryview", "property", "classmethod", "staticmethod"
+}
+
+def _ann_to_str(n: ast.AST | None) -> str:
+    if n is None:
+        return ""
+    try:
+        return ast.unparse(n)
+    except Exception:
+        if isinstance(n, ast.Name):
+            return n.id
+        if isinstance(n, ast.Constant) and isinstance(n.value, str):
+            return n.value
+        return ""
+
+def _strip_typing(s: str) -> str:
+    t = (s or "").strip()
+    t = t.replace("collections.abc.", "")
+    return t.strip()
+
+def _unwrap_optional(s: str) -> str:
+    t = _strip_typing(s)
+    t = _QUOTED_ATOM_RE.sub(r"\2", t)
+    m = _OPTIONAL_RE.match(t)
+    if m:
+        return m.group(2).strip()
+    m2 = _UNION_RE.match(t)
+    if m2:
+        parts = [p.strip() for p in m2.group(2).split(",")]
+        parts = [p for p in parts if p and p != "None"]
+        if len(parts) == 1:
+            return parts[0]
+    m3 = _PEP604_RE.match(t)
+    if m3:
+        left = (m3.group(1) or "").strip()
+        right = (m3.group(2) or "").strip()
+        return (left or right).strip()
+    return t
+
+def _collection_inner(s: str) -> tuple[bool, str]:
+    t = _unwrap_optional(s)
+    m = _COLLECTION_RE.match(t)
+    if not m:
+        return False, ""
+    inner = _unwrap_optional(m.group(2).strip())
+    return True, inner
+
+def _normalize_ref_name(type_str: str) -> str:
+    t = _unwrap_optional(type_str).strip()
+    if not t:
+        return ""
+    if (t.startswith('"') and t.endswith('"')) or (t.startswith("'") and t.endswith("'")):
+        t = t[1:-1].strip()
+    if t.startswith("ForwardRef("):
+        t = t.removeprefix("ForwardRef(").removesuffix(")").strip()
+        t = t.strip('"').strip("'").strip()
+    if "." in t:
+        t = t.split(".")[-1].strip()
+    return t
+
+def _fk_guess_target(field_name: str, model_names: set[str]) -> str | None:
+    n = field_name.strip()
+    if not n:
+        return None
+    base = n
+    if base.endswith("_id"):
+        base = base[:-3]
+    elif base.endswith("Id"):
+        base = base[:-2]
+    base = base.strip("_")
+    if not base:
+        return None
+    candidates = {base, base.capitalize(), base[:1].upper() + base[1:], base.replace("_", "").capitalize()}
+    for c in candidates:
+        if c in model_names:
+            return c
+    return None
+
+@dataclass(frozen=True)
+class _ModelInfo:
+    name: str
+    file: Path
+    fields: list[tuple[str, str, bool]]
+
+def _extract_classes_fields_from_ast(py_file: Path) -> list[_ModelInfo]:
+    try:
+        code = py_file.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return []
+    try:
+        tree = ast.parse(code)
+    except Exception:
+        return []
+    out: list[_ModelInfo] = []
+    for node in tree.body:
+        if not isinstance(node, ast.ClassDef):
+            continue
+        cls_name = node.name
+        fields: list[tuple[str, str, bool]] = []
+        for b in node.body:
+            if isinstance(b, ast.AnnAssign) and isinstance(b.target, ast.Name):
+                fname = b.target.id
+                ftype = _ann_to_str(b.annotation) or "Any"
+                is_pk = fname.lower() in {"id", "pk"}
+                fields.append((fname, ftype, is_pk))
+            elif isinstance(b, ast.Assign) and len(b.targets) == 1 and isinstance(b.targets[0], ast.Name):
+                fname = b.targets[0].id
+                is_pk = fname.lower() in {"id", "pk"}
+                fields.append((fname, "Any", is_pk))
+        if fields:
+            out.append(_ModelInfo(name=cls_name, file=py_file, fields=fields))
+    return out
+
+def _build_model_index(project_root: Path) -> dict[str, _ModelInfo]:
+    model_files: set[Path] = set()
+    try:
+        for f in find_all_supported_files(project_root):
+            if f.suffix.lower() != ".py":
+                continue
+            defs = extract_models_for_file(f, project_root) or []
+            if defs:
+                model_files.add(f.resolve())
+    except Exception:
+        pass
+    if not model_files:
+        try:
+            for f in find_all_supported_files(project_root):
+                if f.suffix.lower() != ".py":
+                    continue
+                parts = {p.lower() for p in f.parts}
+                if parts & {"models", "model", "entity", "entities", "domain"}:
+                    model_files.add(f.resolve())
+        except Exception:
+            pass
+    idx: dict[str, _ModelInfo] = {}
+    for mf in sorted(model_files):
+        for mi in _extract_classes_fields_from_ast(mf):
+            idx.setdefault(mi.name, mi)
+    return idx
+
+def _infer_forward_rels(model: _ModelInfo, model_names: set[str]) -> list[PyRel]:
+    rels: list[PyRel] = []
+    for fname, ftype, _pk in model.fields:
+        if not fname or not ftype:
+            continue
+        is_coll, inner = _collection_inner(ftype)
+        if is_coll:
+            tgt = _normalize_ref_name(inner)
+            if tgt and tgt in model_names and tgt != model.name and tgt not in _BUILTIN_TYPES:
+                rels.append(PyRel(kind="OneToMany", target=tgt, field=fname, via="type"))
+            continue
+        base = _normalize_ref_name(ftype)
+        if base and base in model_names and base != model.name and base not in _BUILTIN_TYPES:
+            kind = "OneToOne" if fname.lower() in _EMBED_HINTS else "ManyToOne"
+            rels.append(PyRel(kind=kind, target=base, field=fname, via="type"))
+            continue
+        if fname.endswith(_FK_SUFFIXES) or fname.lower().endswith("_id"):
+            tgt = _fk_guess_target(fname, model_names)
+            if tgt and tgt != model.name:
+                rels.append(PyRel(kind="ManyToOne", target=tgt, field=fname, via="fk"))
+    return rels
+
+def _has_collection(rels_by_model: dict[str, list[PyRel]], src: str, dst: str) -> bool:
+    return any(r.target == dst and r.kind in {"OneToMany", "ManyToMany"} for r in rels_by_model.get(src, []))
+
+def _has_scalar(rels_by_model: dict[str, list[PyRel]], src: str, dst: str) -> bool:
+    return any(r.target == dst and r.kind in {"ManyToOne", "OneToOne"} for r in rels_by_model.get(src, []))
+
+def _upgrade_one_to_one(rels_by_model: dict[str, list[PyRel]]) -> None:
+    for src, rels in list(rels_by_model.items()):
+        upgraded: list[PyRel] = []
+        for r in rels:
+            if r.kind not in {"ManyToOne", "OneToOne"}:
+                upgraded.append(r)
+                continue
+            dst = r.target
+            if (_has_scalar(rels_by_model, dst, src) and not _has_collection(rels_by_model, src, dst) and not _has_collection(rels_by_model, dst, src)):
+                upgraded.append(PyRel(kind="OneToOne", target=dst, field=r.field, via=r.via))
+            else:
+                upgraded.append(r)
+        rels_by_model[src] = upgraded
+
+def _upgrade_many_to_many(rels_by_model: dict[str, list[PyRel]]) -> None:
+    for src, rels in list(rels_by_model.items()):
+        newrels: list[PyRel] = []
+        for r in rels:
+            if r.kind != "OneToMany":
+                newrels.append(r)
+                continue
+            dst = r.target
+            if any(x.kind == "OneToMany" and x.target == src for x in rels_by_model.get(dst, [])):
+                newrels.append(PyRel(kind="ManyToMany", target=dst, field=r.field, via=r.via))
+            else:
+                newrels.append(r)
+        rels_by_model[src] = newrels
+
+def python_collect_relationship_map(target: Path, project_root: Path):
+    idx = _build_model_index(project_root)
+    model_names = set(idx.keys())
+    candidates = [m for m in idx.values() if m.file.resolve() == target.resolve()]
+    if not candidates:
+        return target.stem, [], [], {}, []
+    stem = target.stem
+    main = next((m for m in candidates if m.name.lower() == stem.lower()), candidates[0])
+    model_name = main.name
+    rels_by_model: dict[str, list[PyRel]] = {name: _infer_forward_rels(mi, model_names) for name, mi in idx.items()}
+    _upgrade_one_to_one(rels_by_model)
+    _upgrade_many_to_many(rels_by_model)
+    forward = rels_by_model.get(model_name, [])
+    fields_by_entity: dict[str, list[tuple[str, str, bool]]] = {}
+    for r in forward:
+        if r and r.target and r.target in idx:
+            fields_by_entity[r.target] = idx[r.target].fields
+    reverse: list[tuple[str, PyRel]] = []
+    for src, rels in rels_by_model.items():
+        if src == model_name:
+            continue
+        for r in rels:
+            if r and r.target == model_name:
+                reverse.append((src, PyRel(kind=r.kind, target=model_name, field=r.field, via=r.via)))
+                if src in idx:
+                    fields_by_entity.setdefault(src, idx[src].fields)
+    reverse.sort(key=lambda x: (x[0].lower(), x[1].kind, x[1].field.lower()))
+    return model_name, main.fields, forward, fields_by_entity, reverse

codeintel_cli/context/python_service.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+from pathlib import Path
+import ast
+import re
+from typing import Any
+
+from ..scanner.scanner import find_all_supported_files
+from ..context.python_rel import python_collect_relationship_map
+
+_ROUTE_DECORATORS = {"route", "get", "post", "put", "delete", "patch", "api_route", "app.route", "router.get", "router.post"}
+
+def _extract_routes(tree: ast.AST) -> list[dict]:
+    routes = []
+    
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.FunctionDef):
+            continue
+        
+        for dec in node.decorator_list:
+            route_info = _parse_route_decorator(dec)
+            if route_info:
+                route_info["handler"] = node.name
+                routes.append(route_info)
+                break
+    
+    return routes
+
+def _parse_route_decorator(dec: ast.AST) -> dict | None:
+    method = "GET"
+    path = "/"
+    
+    if isinstance(dec, ast.Call):
+        if isinstance(dec.func, ast.Attribute):
+            attr_name = dec.func.attr.lower()
+            if attr_name in {"get", "post", "put", "delete", "patch"}:
+                method = attr_name.upper()
+        elif isinstance(dec.func, ast.Name):
+            func_name = dec.func.id.lower()
+            if func_name in {"get", "post", "put", "delete", "patch"}:
+                method = func_name.upper()
+        
+        if dec.args:
+            first_arg = dec.args[0]
+            if isinstance(first_arg, ast.Constant) and isinstance(first_arg.value, str):
+                path = first_arg.value
+    
+    elif isinstance(dec, ast.Attribute):
+        attr_name = dec.attr.lower()
+        if attr_name in _ROUTE_DECORATORS:
+            return {"method": method, "path": path}
+    
+    elif isinstance(dec, ast.Name):
+        if dec.id.lower() in _ROUTE_DECORATORS:
+            return {"method": method, "path": path}
+    
+    if path != "/":
+        return {"method": method, "path": path}
+    
+    return None
+
+def _extract_functions(tree: ast.AST) -> list[dict]:
+    functions = []
+    
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            if node.name.startswith("_"):
+                continue
+            
+            params = []
+            for arg in node.args.args:
+                if arg.arg == "self":
+                    continue
+                param_type = "Any"
+                if arg.annotation:
+                    try:
+                        param_type = ast.unparse(arg.annotation)
+                    except Exception:
+                        pass
+                params.append(f"{arg.arg}: {param_type}")
+            
+            ret_type = ""
+            if node.returns:
+                try:
+                    ret_type = ast.unparse(node.returns)
+                except Exception:
+                    pass
+            
+            functions.append({
+                "name": node.name,
+                "params": ", ".join(params),
+                "return": ret_type,
+            })
+    
+    return functions
+
+def _find_models_used(tree: ast.AST, project_root: Path) -> dict[str, Any]:
+    model_names = set()
+    
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Name):
+            name = node.id
+            if name and name[0].isupper() and len(name) > 2:
+                model_names.add(name)
+    
+    models = {}
+    all_files = find_all_supported_files(project_root)
+    
+    for model_name in model_names:
+        for f in all_files:
+            if f.suffix.lower() != ".py":
+                continue
+            if f.stem.lower() != model_name.lower():
+                continue
+            parts = {p.lower() for p in f.parts}
+            if not (parts & {"model", "models", "entity", "entities", "domain"}):
+                continue
+            
+            try:
+                _, fields, rels, _, _ = python_collect_relationship_map(f, project_root)
+                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(tree: ast.AST) -> list[dict]:
+    repos = []
+    
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.Assign, ast.AnnAssign)):
+            target_name = ""
+            if isinstance(node, ast.Assign) and node.targets:
+                target = node.targets[0]
+                if isinstance(target, ast.Name):
+                    target_name = target.id
+            elif isinstance(node, ast.AnnAssign):
+                if isinstance(node.target, ast.Name):
+                    target_name = node.target.id
+            
+            if "repo" in target_name.lower() or "dal" in target_name.lower():
+                methods = [
+                    "get(id)",
+                    "save(entity)",
+                    "delete(id)",
+                    "find_all()",
+                    "find_by(**kwargs)",
+                ]
+                repos.append({"name": target_name, "methods": methods})
+    
+    return repos
+
+def analyze_python_service(service_file: Path, project_root: Path) -> dict:
+    try:
+        code = service_file.read_text(encoding="utf-8", errors="ignore")
+        tree = ast.parse(code)
+    except Exception:
+        tree = ast.Module(body=[], type_ignores=[])
+    
+    service_name = service_file.stem
+    
+    routes = _extract_routes(tree)
+    functions = _extract_functions(tree)
+    models = _find_models_used(tree, project_root)
+    repos = _find_repositories(tree)
+    
+    flow = []
+    if routes:
+        rt = routes[0]
+        flow.append(f"{rt['method']} {rt['path']}")
+        flow.append("  ↓")
+        flow.append(f"{rt['handler']}()")
+        flow.append("  ↓")
+        if models:
+            model_name = list(models.keys())[0]
+            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()")
+    
+    summary = {
+        "Routes": len(routes),
+        "Functions": len(functions),
+        "Models used": len(models),
+        "Data access": len(repos),
+    }
+    
+    return {
+        "service_name": service_name,
+        "endpoints": routes,
+        "methods": functions,
+        "models": models,
+        "repositories": repos,
+        "flow": flow,
+        "summary": summary,
+    }

codeintel_cli/core/fuzzy.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from pathlib import Path
+import difflib
+
+
+def rank_paths(query: str, files: list[Path], root: Path, top: int = 3) -> list[tuple[Path, float]]:
+    q_raw = query.strip()
+    q_lower = q_raw.replace("/", "\\").lower()
+
+    if not q_lower:
+        return []
+
+    q_stem = Path(q_raw).stem.lower()
+    scored: list[tuple[Path, float]] = []
+
+    for p in files:
+        if p.name == "__init__.py":
+            continue
+
+        try:
+            rel = str(p.relative_to(root)).replace("/", "\\").lower()
+        except Exception:
+            rel = str(p).replace("/", "\\").lower()
+
+        stem = p.stem.lower()
+        name = p.name.lower()
+        score = 0.0
+
+        if stem == q_stem:
+            score = 0.98
+        elif name == q_lower:
+            score = 0.97
+        elif rel == q_lower:
+            score = 0.96
+        elif rel.endswith(q_lower):
+            score = 0.92
+        elif stem.startswith(q_stem):
+            score = 0.88
+        elif name.startswith(q_lower):
+            score = 0.86
+        elif q_stem in stem:
+            score = 0.82
+        elif q_lower in rel:
+            score = 0.78
+        elif q_lower in name:
+            score = 0.74
+        else:
+            ratio_stem = difflib.SequenceMatcher(a=q_stem, b=stem).ratio()
+            ratio_rel = difflib.SequenceMatcher(a=q_lower, b=rel).ratio()
+            ratio = max(ratio_stem, ratio_rel)
+            if ratio >= 0.5:
+                score = 0.50 + (ratio - 0.5) * 0.4
+
+        if score > 0:
+            scored.append((p, score))
+
+    scored.sort(key=lambda x: (-x[1], str(x[0]).lower()))
+    return scored[: min(top, len(scored))]
+
+
+def fuzzy_top_matches(query: str, files: list[Path], root: Path, top: int = 3) -> list[tuple[Path, float]]:
+    return rank_paths(query, files, root, top=top)
+
+
+def fuzzy_is_confident(ranked: list[tuple[Path, float]], min_score: float = 0.90, gap: float = 0.05) -> bool:
+    if not ranked:
+        return False
+    if ranked[0][1] < min_score:
+        return False
+    if len(ranked) == 1:
+        return True
+    return (ranked[0][1] - ranked[1][1]) >= gap

codeintel_cli/core/opener.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+import os
+import subprocess
+
+
+def find_files(query: str, root: Path, files: list[Path]) -> list[Path]:
+    """
+    Return files whose relative path contains the query (case-insensitive).
+    """
+    q = query.replace("/", "\\").lower()
+    matches: list[Path] = []
+
+    for f in files:
+        rel = str(f.relative_to(root)).lower()
+        if q in rel:
+            matches.append(f)
+
+    return sorted(matches)
+
+
+def open_file(path: Path) -> None:
+    """
+    Open a file in VS Code if available, otherwise open with default app (Windows).
+    """
+    # Try VS Code first (if 'code' is in PATH)
+    try:
+        r = subprocess.run(["where", "code"], capture_output=True, text=True)
+        if r.returncode == 0:
+            subprocess.run(["code", str(path)], check=False)
+            return
+    except Exception:
+        pass
+
+    # Fallback to Windows default app
+    os.startfile(path)  # type: ignore[attr-defined]

codeintel_cli/core/project.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+SKIP_DIRS: set[str] = {
+    "__pycache__",
+    "venv",
+    ".venv",
+    ".git",
+    "site-packages",
+    "codeintel.egg-info",
+    "build",
+    "dist",
+    ".mypy_cache",
+    ".pytest_cache",
+}
+
+
+def find_project_root(start: Path) -> Path:
+    start = start.resolve()
+    for p in [start] + list(start.parents):
+        if (p / "pyproject.toml").exists():
+            return p
+        if (p / "setup.py").exists():
+            return p
+        if (p / ".git").exists():
+            return p
+        if list(p.glob("*.egg-info")):
+            return p
+    return start
+
+
+def is_skipped_path(path: Path) -> bool:
+    return any(part in SKIP_DIRS for part in path.parts)

codeintel_cli/core/resolve_folder.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from pathlib import Path
+import typer
+
+from .project import find_project_root, is_skipped_path
+from .fuzzy import fuzzy_top_matches
+from ..errors import InvalidPathError
+
+
+def resolve_target_folder(
+    query: str,
+    *,
+    top: int = 3,
+    auto_threshold: float = 0.90,
+    min_threshold: float = 0.60,
+) -> tuple[Path, Path]:
+    root = find_project_root(Path.cwd())
+
+    p = Path(query)
+    if p.exists() and p.is_dir():
+        return p.resolve(), root
+
+    p2 = root / query
+    if p2.exists() and p2.is_dir():
+        return p2.resolve(), root
+
+    folders = [d.resolve() for d in root.rglob("*") if d.is_dir() and not is_skipped_path(d)]
+
+    qname = Path(query).name
+    exact = [d for d in folders if d.name == qname]
+    if len(exact) == 1:
+        return exact[0], root
+
+    if len(exact) > 1:
+        typer.echo("Multiple exact matches:")
+        for i, m in enumerate(exact[:top], 1):
+            typer.echo(f"{i}. {m}")
+        choice = typer.prompt("Select number (0=cancel)", type=int, default=0)
+        if choice == 0:
+            raise typer.Exit()
+        if choice < 1 or choice > min(len(exact), top):
+            raise typer.BadParameter("Invalid selection.")
+        return exact[choice - 1], root
+
+    matches = fuzzy_top_matches(query, folders, root, top=top)
+    if not matches:
+        raise InvalidPathError(message="Folder not found", path=Path(query))
+
+    best_path, best_score = matches[0]
+    if best_score < min_threshold:
+        raise InvalidPathError(message="Folder not found (low-confidence)", path=Path(query))
+
+    second = matches[1][1] if len(matches) > 1 else 0.0
+    if best_score >= auto_threshold and (best_score - second) >= 0.05:
+        return best_path.resolve(), root
+
+    typer.echo("Did you mean:")
+    for i, (p, score) in enumerate(matches, 1):
+        typer.echo(f"{i}. {p}   score={score:.2f}")
+
+    choice = typer.prompt("Select number (0=cancel)", type=int, default=0)
+    if choice == 0:
+        raise typer.Exit()
+    if choice < 1 or choice > len(matches):
+        raise typer.BadParameter("Invalid selection.")
+
+    return matches[choice - 1][0].resolve(), root