aja-codeintel 0.1.0__tar.gz → 0.1.2__tar.gz

{aja_codeintel-0.1.0 → aja_codeintel-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aja-codeintel
-Version: 0.1.0
+Version: 0.1.2
 Summary: CodeIntel CLI tool
 Author: Your Name
 License: MIT License

{aja_codeintel-0.1.0 → aja_codeintel-0.1.2}/aja_codeintel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aja-codeintel
-Version: 0.1.0
+Version: 0.1.2
 Summary: CodeIntel CLI tool
 Author: Your Name
 License: MIT License

{aja_codeintel-0.1.0 → aja_codeintel-0.1.2}/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/endpoints_cmd.py
 codeintel_cli/commands/project/folder_cmd.py
 codeintel_cli/commands/project/imports_cmd.py
 codeintel_cli/commands/project/models_cmd.py
@@ -51,6 +52,11 @@ codeintel_cli/db/__init__.py
 codeintel_cli/db/cache.py
 codeintel_cli/db/operations.py
 codeintel_cli/db/schema.py
+codeintel_cli/endpoints/__init__.py
+codeintel_cli/endpoints/java_spring.py
+codeintel_cli/endpoints/models.py
+codeintel_cli/endpoints/python_web.py
+codeintel_cli/endpoints/scan.py
 codeintel_cli/graph/__init__.py
 codeintel_cli/graph/builder.py
 codeintel_cli/graph/query.py

{aja_codeintel-0.1.0 → aja_codeintel-0.1.2}/codeintel_cli/commands/project/__init__.py

@@ -11,7 +11,7 @@ from .tree_cmd import register_tree
 from .modeltree_cmd import register_modeltree
 from .models_cmd import register_models
 from .servicemap_cmd import register_servicemap
-
+from .endpoints_cmd import register_endpoints
 
 def register_project_commands(app: typer.Typer) -> None:
     register_scan(app)
@@ -23,4 +23,5 @@ def register_project_commands(app: typer.Typer) -> None:
     register_tree(app)
     register_modeltree(app)
     register_models(app)
-    register_servicemap(app)
+    register_servicemap(app)
+    register_endpoints(app)

aja_codeintel-0.1.2/codeintel_cli/commands/project/endpoints_cmd.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import json
+import time
+from collections import defaultdict
+from pathlib import Path
+
+import typer
+
+from ...errors import InvalidPathError
+from ...core.project import find_project_root
+from ...endpoints.scan import EndpointScanOptions, iter_supported_source_files
+from ...endpoints.java_spring import extract_spring_endpoints
+from ...endpoints.python_web import extract_python_endpoints
+
+
+def _validate_folder(path: str) -> Path:
+    folder = Path(path).resolve()
+    if not folder.exists() or not folder.is_dir():
+        raise InvalidPathError(message="Invalid folder", path=folder)
+    return folder
+
+
+def _norm_path(p: str) -> str:
+    return p.replace("\\", "/")
+
+
+def _guess_access(path: str) -> str:
+    if path.startswith("/admin"):
+        return "ADMIN"
+    if path.startswith("/me"):
+        return "CUSTOMER"
+    if path.startswith("/api/auth"):
+        return "PUBLIC"
+    return "PUBLIC"
+
+
+def register_endpoints(app: typer.Typer) -> None:
+    @app.command()
+    def endpoints(
+        path: str = typer.Argument(".", help="Folder to scan"),
+        lang: str = typer.Option("all", "--lang", help="all | py | java"),
+        hidden: bool = typer.Option(False, "--hidden", help="Include hidden dotfiles/folders"),
+        no_gitignore: bool = typer.Option(False, "--no-gitignore", help="Do not apply .gitignore rules"),
+        fmt: str = typer.Option("clean", "--format", help="clean | text | json"),
+        only_main: bool = typer.Option(True, "--only-main/--all-sources", help="Only scan src/main (skip tests)"),
+        only_api: bool = typer.Option(False, "--only-api", help="Only show paths starting with /api"),
+        dedupe: bool = typer.Option(True, "--dedupe/--no-dedupe", help="Remove duplicates (method+path)"),
+    ):
+        folder = _validate_folder(path)
+        project_root = find_project_root(folder)
+
+        opts = EndpointScanOptions(
+            show_hidden=hidden,
+            use_gitignore=not no_gitignore,
+        )
+
+        lang_norm = lang.strip().lower()
+        if lang_norm not in {"all", "py", "java"}:
+            raise typer.BadParameter("Invalid --lang. Use: all | py | java")
+
+        t0 = time.perf_counter()
+        all_eps = []
+
+        files = list(iter_supported_source_files(project_root, opts))
+
+        for f in files:
+            suf = f.suffix.lower()
+            if lang_norm == "py" and suf != ".py":
+                continue
+            if lang_norm == "java" and suf != ".java":
+                continue
+
+            try:
+                src = f.read_text(encoding="utf-8", errors="ignore")
+            except Exception:
+                continue
+
+            if suf == ".java":
+                all_eps.extend(extract_spring_endpoints(src, str(f)))
+            elif suf == ".py":
+                all_eps.extend(extract_python_endpoints(src, str(f)))
+
+        if only_main:
+            filtered = []
+            for e in all_eps:
+                fp = _norm_path(e.file)
+                if "/src/test/" in fp:
+                    continue
+                if "/src/main/" in fp or "/main/" in fp:
+                    filtered.append(e)
+            all_eps = filtered
+
+        if only_api:
+            all_eps = [e for e in all_eps if e.path.startswith("/api")]
+
+        if dedupe:
+            seen = set()
+            uniq = []
+            for e in all_eps:
+                key = (e.method, e.path)
+                if key in seen:
+                    continue
+                seen.add(key)
+                uniq.append(e)
+            all_eps = uniq
+
+        all_eps.sort(key=lambda e: (e.path, e.method, e.file, e.line))
+        elapsed = time.perf_counter() - t0
+
+        fmt_norm = fmt.strip().lower()
+
+        if fmt_norm == "json":
+            typer.echo(json.dumps([e.to_dict() for e in all_eps], indent=2))
+            return
+
+        if fmt_norm == "text":
+            typer.echo(f"Project: {project_root}")
+            typer.echo(f"Found {len(all_eps)} endpoints in {elapsed:.3f}s")
+            typer.echo("")
+            for e in all_eps:
+                roles = set(e.roles or [])
+                role_str = f" {{{', '.join(sorted(roles))}}}" if roles else f" {{{_guess_access(e.path)}}}"
+                typer.echo(f"{e.method:6} {e.path:40}{role_str}  {e.file}:{e.line}  {e.handler}  <{e.framework}>")
+            return
+
+        typer.echo(f"Found {len(all_eps)} endpoints in {elapsed:.3f}s")
+        typer.echo("")
+
+        methods_by_path: dict[str, set[str]] = defaultdict(set)
+        roles_by_key: dict[tuple[str, str], set[str]] = defaultdict(set)
+
+        for e in all_eps:
+            methods_by_path[e.path].add(e.method)
+            if e.roles:
+                roles_by_key[(e.path, e.method)].update(e.roles)
+
+        paths = sorted(methods_by_path.keys())
+        for idx, p in enumerate(paths, start=1):
+            methods = sorted(methods_by_path[p])
+            parts = []
+            for m in methods:
+                role_set = roles_by_key.get((p, m), set())
+                role_str = f"{{{', '.join(sorted(role_set))}}}" if role_set else f"{{{_guess_access(p)}}}"
+                parts.append(f"{m}{role_str}")
+            typer.echo(f"{idx:02d}. {p}  [{', '.join(parts)}]")

aja_codeintel-0.1.2/codeintel_cli/endpoints/__init__.py

@@ -0,0 +1 @@
+__all__ = []

aja_codeintel-0.1.2/codeintel_cli/endpoints/java_spring.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import re
+from typing import List, Tuple, Optional, Set
+
+from .models import Endpoint
+
+
+_MAPPING_ANN = {
+    "GetMapping",
+    "PostMapping",
+    "PutMapping",
+    "DeleteMapping",
+    "PatchMapping",
+    "RequestMapping",
+}
+
+_ANNOT_RE = re.compile(r'@\s*([A-Za-z_]\w*)\s*(\((.*?)\))?', re.DOTALL)
+_CLASS_RE = re.compile(r'\b(class|record)\s+([A-Za-z_]\w*)\b')
+_METHOD_RE = re.compile(r'(public|protected|private)?\s*(static\s+)?[\w<>\[\], ?]+\s+([A-Za-z_]\w*)\s*\(')
+
+_PREAUTHORIZE_RE = re.compile(r'@PreAuthorize\s*\(\s*"([^"]+)"\s*\)')
+_SECURED_RE = re.compile(r'@Secured\s*\((.*?)\)')
+_ROLESALLOWED_RE = re.compile(r'@RolesAllowed\s*\((.*?)\)')
+
+_HASROLE_RE = re.compile(r"hasRole\s*\(\s*'([^']+)'\s*\)")
+_HASANYROLE_RE = re.compile(r"hasAnyRole\s*\(\s*([^\)]+)\)")
+
+
+def _extract_paths(arg_str: str) -> List[str]:
+    return re.findall(r'"([^"]+)"', arg_str or "")
+
+
+def _normalize_join(base: str, sub: str) -> str:
+    if not base:
+        return sub or "/"
+    if not sub:
+        return base
+    if base.endswith("/") and sub.startswith("/"):
+        return base[:-1] + sub
+    if not base.endswith("/") and not sub.startswith("/"):
+        return base + "/" + sub
+    return base + sub
+
+
+def _methods_from_annotation(ann: str, args: str) -> List[str]:
+    ann = ann.lower()
+    if ann == "getmapping":
+        return ["GET"]
+    if ann == "postmapping":
+        return ["POST"]
+    if ann == "putmapping":
+        return ["PUT"]
+    if ann == "deletemapping":
+        return ["DELETE"]
+    if ann == "patchmapping":
+        return ["PATCH"]
+    if ann == "requestmapping":
+        return re.findall(r'RequestMethod\.([A-Z]+)', args or "")
+    return []
+
+
+def _roles_from_expr(expr: str) -> Set[str]:
+    roles: Set[str] = set()
+    for m in _HASROLE_RE.finditer(expr):
+        roles.add(m.group(1))
+    for m in _HASANYROLE_RE.finditer(expr):
+        for r in re.findall(r"'([^']+)'", m.group(1)):
+            roles.add(r)
+    return roles
+
+
+def _roles_from_strings(arg: str) -> Set[str]:
+    out: Set[str] = set()
+    for s in re.findall(r'"([^"]+)"', arg or ""):
+        if s.startswith("ROLE_"):
+            s = s[5:]
+        out.add(s)
+    return out
+
+
+def _extract_roles_block(text: str) -> Set[str]:
+    roles: Set[str] = set()
+    for m in _PREAUTHORIZE_RE.finditer(text):
+        roles |= _roles_from_expr(m.group(1))
+    for m in _SECURED_RE.finditer(text):
+        roles |= _roles_from_strings(m.group(1))
+    for m in _ROLESALLOWED_RE.finditer(text):
+        roles |= _roles_from_strings(m.group(1))
+    return roles
+
+
+def extract_spring_endpoints(java_source: str, file_path: str) -> List[Endpoint]:
+    endpoints: List[Endpoint] = []
+    lines = java_source.splitlines()
+
+    mcls = _CLASS_RE.search(java_source)
+    if not mcls:
+        return []
+
+    class_pos = mcls.start()
+    controller = mcls.group(2)
+    pre = java_source[:class_pos]
+
+    if "@RestController" not in pre and "@Controller" not in pre:
+        return []
+
+    base_path = ""
+    for m in _ANNOT_RE.finditer(pre):
+        if m.group(1) == "RequestMapping":
+            ps = _extract_paths(m.group(3) or "")
+            if ps:
+                base_path = ps[0]
+
+    class_roles = _extract_roles_block(pre)
+
+    pending: List[Tuple[str, str, int]] = []
+
+    for i, line in enumerate(lines, start=1):
+        s = line.strip()
+
+        if s.startswith("@"):
+            am = _ANNOT_RE.search(s)
+            if am and am.group(1) in _MAPPING_ANN:
+                pending.append((am.group(1), am.group(3) or "", i))
+            continue
+
+        mm = _METHOD_RE.search(s)
+        if mm and pending:
+            handler = mm.group(3)
+            method_roles = _extract_roles_block("\n".join(lines[max(0, i - 8):i]))
+            roles = class_roles | method_roles
+
+            for ann, args, ln in pending:
+                for meth in _methods_from_annotation(ann, args):
+                    paths = _extract_paths(args) or [""]
+                    for p in paths:
+                        full = _normalize_join(base_path, p)
+                        endpoints.append(
+                            Endpoint(
+                                method=meth,
+                                path=full,
+                                file=file_path,
+                                line=ln,
+                                handler=handler,
+                                framework="spring",
+                                controller=controller,
+                                roles=roles or None,
+                            )
+                        )
+            pending = []
+
+    return endpoints

aja_codeintel-0.1.2/codeintel_cli/endpoints/models.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, Any, Set
+
+
+@dataclass(frozen=True)
+class Endpoint:
+    method: str
+    path: str
+    file: str
+    line: int
+    handler: str
+    framework: str
+    controller: Optional[str] = None
+    roles: Optional[Set[str]] = None  # e.g. {"ADMIN","CUSTOMER"}
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        
+        if self.roles is not None:
+            d["roles"] = sorted(self.roles)
+        return d

aja_codeintel-0.1.2/codeintel_cli/endpoints/python_web.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import ast
+from typing import List, Optional, Tuple
+
+from .models import Endpoint
+
+_FASTAPI_METHODS = {"get", "post", "put", "delete", "patch", "options", "head"}
+
+
+def _get_str(node: ast.AST) -> Optional[str]:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value
+    return None
+
+
+def _call_name(expr: ast.AST) -> Tuple[Optional[str], Optional[str]]:
+    if isinstance(expr, ast.Call):
+        func = expr.func
+        if isinstance(func, ast.Attribute) and isinstance(func.value, ast.Name):
+            return func.value.id, func.attr
+    return None, None
+
+
+def _extract_flask_methods(dec_call: ast.Call) -> List[str]:
+    for kw in dec_call.keywords:
+        if kw.arg == "methods" and isinstance(kw.value, (ast.List, ast.Tuple)):
+            ms: List[str] = []
+            for el in kw.value.elts:
+                s = _get_str(el)
+                if s:
+                    ms.append(s.upper())
+            return sorted(set(ms)) if ms else ["GET"]
+    return ["GET"]
+
+
+def extract_python_endpoints(py_source: str, file_path: str) -> List[Endpoint]:
+    try:
+        tree = ast.parse(py_source)
+    except SyntaxError:
+        return []
+
+    endpoints: List[Endpoint] = []
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.FunctionDef):
+            continue
+
+        if not node.decorator_list:
+            continue
+
+        handler = node.name
+
+        for dec in node.decorator_list:
+            if not isinstance(dec, ast.Call):
+                continue
+
+            obj, meth = _call_name(dec)
+            if not obj or not meth:
+                continue
+
+            # path is usually first arg
+            pnode = dec.args[0] if dec.args else None
+            path = _get_str(pnode) if pnode else None
+            if not path or not path.startswith("/"):
+                continue
+
+            low = meth.lower()
+
+            # FastAPI: @app.get("/x") / @router.post("/x")
+            if low in _FASTAPI_METHODS:
+                endpoints.append(
+                    Endpoint(
+                        method=low.upper(),
+                        path=path,
+                        file=file_path,
+                        line=getattr(dec, "lineno", getattr(node, "lineno", 1)),
+                        handler=handler,
+                        framework="fastapi",
+                    )
+                )
+                continue
+
+            # Flask: @app.route("/x", methods=[...])
+            if low == "route":
+                ms = _extract_flask_methods(dec)
+                for m in ms:
+                    endpoints.append(
+                        Endpoint(
+                            method=m,
+                            path=path,
+                            file=file_path,
+                            line=getattr(dec, "lineno", getattr(node, "lineno", 1)),
+                            handler=handler,
+                            framework="flask",
+                        )
+                    )
+
+    return endpoints

aja_codeintel-0.1.2/codeintel_cli/endpoints/scan.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, Optional
+
+# Optional: pip install pathspec
+try:
+    import pathspec  # type: ignore
+except Exception:  # pragma: no cover
+    pathspec = None
+
+from ..core.project import find_project_root, SKIP_DIRS
+from ..commands.project.tree_cmd import DEFAULT_IGNORE_NAMES  # reuse your ignore set
+
+
+@dataclass(frozen=True)
+class EndpointScanOptions:
+    show_hidden: bool
+    use_gitignore: bool
+
+
+def _is_hidden_name(name: str) -> bool:
+    return name.startswith(".")
+
+
+def _load_gitignore_spec(root: Path):
+    if pathspec is None:
+        return None
+    gi = root / ".gitignore"
+    if not gi.exists():
+        return None
+
+    lines: list[str] = []
+    for line in gi.read_text(encoding="utf-8", errors="ignore").splitlines():
+        s = line.strip()
+        if not s or s.startswith("#"):
+            continue
+        lines.append(s)
+
+    if not lines:
+        return None
+    return pathspec.PathSpec.from_lines("gitwildmatch", lines)
+
+
+def _gitignore_matches(spec, rel_posix: str, is_dir: bool) -> bool:
+    if spec is None:
+        return False
+    if spec.match_file(rel_posix):
+        return True
+    if is_dir and spec.match_file(rel_posix.rstrip("/") + "/"):
+        return True
+    return False
+
+
+def _is_skipped(p: Path, root: Path, spec, opts: EndpointScanOptions) -> bool:
+    name = p.name
+
+    # reuse your directory skip policy + tree ignores
+    if any(part in SKIP_DIRS for part in p.parts):
+        return True
+    if name in DEFAULT_IGNORE_NAMES:
+        return True
+
+    if _is_hidden_name(name) and not opts.show_hidden:
+        return True
+
+    if opts.use_gitignore and spec is not None:
+        try:
+            rel = p.relative_to(root).as_posix()
+        except Exception:
+            rel = p.as_posix()
+        if _gitignore_matches(spec, rel, p.is_dir()):
+            return True
+
+    return False
+
+
+def iter_supported_source_files(start: Path, opts: EndpointScanOptions) -> Iterable[Path]:
+    start = start.resolve()
+    project_root = find_project_root(start)
+    spec = _load_gitignore_spec(project_root) if opts.use_gitignore else None
+
+    # manual walk so we can prune dirs early
+    stack = [project_root]
+    while stack:
+        cur = stack.pop()
+        if _is_skipped(cur, project_root, spec, opts):
+            continue
+        try:
+            entries = list(cur.iterdir())
+        except Exception:
+            continue
+
+        for e in entries:
+            if _is_skipped(e, project_root, spec, opts):
+                continue
+            if e.is_dir():
+                stack.append(e)
+            elif e.is_file():
+                if e.suffix.lower() in {".java", ".py"}:
+                    yield e.resolve()

{aja_codeintel-0.1.0 → aja_codeintel-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aja-codeintel"
-version = "0.1.0"
+version = "0.1.2"
 description = "CodeIntel CLI tool"
 readme = "README.md"
 requires-python = ">=3.10"