aja-codeintel 0.1.4__tar.gz → 0.1.5__tar.gz

{aja_codeintel-0.1.4 → aja_codeintel-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aja-codeintel
-Version: 0.1.4
+Version: 0.1.5
 Summary: CodeIntel CLI tool
 Author: Shiva Areti
 License: MIT License

{aja_codeintel-0.1.4 → aja_codeintel-0.1.5}/aja_codeintel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aja-codeintel
-Version: 0.1.4
+Version: 0.1.5
 Summary: CodeIntel CLI tool
 Author: Shiva Areti
 License: MIT License

{aja_codeintel-0.1.4 → aja_codeintel-0.1.5}/aja_codeintel.egg-info/SOURCES.txt

@@ -25,10 +25,12 @@ 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/frontend_cmd.py
 codeintel_cli/commands/project/imports_cmd.py
 codeintel_cli/commands/project/models_cmd.py
 codeintel_cli/commands/project/modeltree_cmd.py
 codeintel_cli/commands/project/new.py
+codeintel_cli/commands/project/overview_cmd.py
 codeintel_cli/commands/project/resolve_cmd.py
 codeintel_cli/commands/project/scan_cmd.py
 codeintel_cli/commands/project/servicemap_cmd.py
@@ -56,8 +58,11 @@ codeintel_cli/db/schema.py
 codeintel_cli/endpoints/__init__.py
 codeintel_cli/endpoints/java_spring.py
 codeintel_cli/endpoints/models.py
+codeintel_cli/endpoints/openapi_spec.py
 codeintel_cli/endpoints/python_web.py
 codeintel_cli/endpoints/scan.py
+codeintel_cli/frontend/__init__.py
+codeintel_cli/frontend/server.py
 codeintel_cli/graph/__init__.py
 codeintel_cli/graph/builder.py
 codeintel_cli/graph/query.py

aja_codeintel-0.1.5/codeintel_cli/commands/project/__init__.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import typer
+
+
+def register_project_commands(app: typer.Typer) -> None:
+    from .overview_cmd import register_overview
+    from .models_cmd import register_models
+    from .endpoints_cmd import register_endpoints
+    from .types_cmd import register_types_command
+    from .scan_cmd import register_scan
+    from .context_cmd import register_context
+    from .tree_cmd import register_tree
+    from .imports_cmd import register_imports
+    from .folder_cmd import register_folder
+    from .resolve_cmd import register_resolve
+    from .servicemap_cmd import register_servicemap
+    from .modeltree_cmd import register_modeltree
+    from .version_cmd import register_version
+    from .frontend_cmd import register_frontend
+
+    register_overview(app)
+    register_models(app)
+    register_endpoints(app)
+    register_types_command(app)
+    register_scan(app)
+    register_context(app)
+    register_tree(app)
+    register_imports(app)
+    register_folder(app)
+    register_resolve(app)
+    register_servicemap(app)
+    register_modeltree(app)
+    register_version(app)
+    register_frontend(app)

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

@@ -0,0 +1,335 @@
+# codeintel_cli/commands/project/endpoints_cmd.py
+from __future__ import annotations
+
+import json
+import re
+import time
+from collections import defaultdict
+from fnmatch import fnmatch
+from pathlib import Path
+
+import typer
+
+from ...core.project import find_project_root
+from ...endpoints.java_spring import extract_spring_endpoints
+from ...endpoints.python_web import extract_python_endpoints
+from ...endpoints.scan import EndpointScanOptions, iter_supported_source_files
+from ...endpoints.openapi_spec import extract_openapi_endpoints  # NEW
+from ...errors import InvalidPathError
+
+
+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("\\", "/")
+
+
+_ANYREQ_AUTH_RE = re.compile(r"\.anyRequest\s*\(\s*\)\s*\.authenticated\s*\(\s*\)")
+_LAST_SECURITY_CANDIDATES: list[str] = []
+
+# JHipster / modern Spring Security style:
+#   .requestMatchers("/api/**").authenticated()
+#   .requestMatchers("/api/admin/**").hasAuthority(...)
+_MATCHERS_AUTHZ_RE = re.compile(
+    r"\.(requestMatchers|antMatchers|mvcMatchers)\s*\(\s*([^\)]*?)\)\s*\.\s*(authenticated|hasRole|hasAuthority)\s*\(",
+    re.DOTALL,
+)
+
+
+def _extract_strings(text: str) -> list[str]:
+    return re.findall(r'"([^"]+)"', text or "")
+
+
+def _ant_to_fnmatch(p: str) -> str:
+    return (p or "").replace("**", "*")
+
+
+def _matches_any(path: str, patterns: list[str]) -> bool:
+    for pat in patterns or []:
+        if fnmatch(path, _ant_to_fnmatch(pat)):
+            return True
+    return False
+
+
+def _detect_spring_security_policy(files: list[Path]) -> tuple[bool, list[str]]:
+    global _LAST_SECURITY_CANDIDATES
+    """
+    default_auth:
+      - detects anyRequest().authenticated()
+      - detects requestMatchers(...).authenticated/hasRole/hasAuthority
+      - JHipster fallback: if any security config is found, assume API is secured by default
+    permit_all:
+      - detects requestMatchers(...).permitAll() and extracts only those patterns
+    """
+    default_auth = False
+    permit_all: list[str] = []
+    _LAST_SECURITY_CANDIDATES = []
+    found_security_config = False
+
+    # Exact match: .requestMatchers(...).permitAll()
+    _MATCHERS_PERMITALL_RE = re.compile(
+        r"\.(requestMatchers|antMatchers|mvcMatchers)\s*\(\s*([^\)]*?)\)\s*\.\s*permitAll\s*\(\s*\)",
+        re.DOTALL,
+    )
+
+    SEC_KEYWORDS = (
+        "SecurityFilterChain",
+        "authorizeHttpRequests",
+        "EnableWebSecurity",
+        "HttpSecurity",
+        "org.springframework.security",
+        "springSecurityFilterChain",
+        "requestMatchers",
+        "antMatchers",
+        "mvcMatchers",
+        "AuthenticationManager",
+        "Jwt",
+        "Bearer",
+    )
+
+    for f in files:
+        if f.suffix.lower() != ".java":
+            continue
+
+        fp = str(f).replace("\\", "/").lower()
+        if "/src/test/" in fp or "/target/" in fp or "/build/" in fp:
+            continue
+
+        try:
+            src = f.read_text(encoding="utf-8", errors="ignore")
+        except Exception:
+            continue
+
+        try:
+            parts = [p.lower() for p in f.parts]
+            secpath = any("security" in p for p in parts) or any("config" == p for p in parts)
+        except Exception:
+            secpath = False
+
+        hits = any(k in src for k in SEC_KEYWORDS)
+        if secpath or hits:
+            _LAST_SECURITY_CANDIDATES.append(str(f))
+
+        if not hits and not secpath:
+            continue
+
+        found_security_config = True
+
+        if _ANYREQ_AUTH_RE.search(src):
+            default_auth = True
+
+        if not default_auth:
+            for mm in _MATCHERS_AUTHZ_RE.finditer(src):
+                args = mm.group(2) or ""
+                paths = _extract_strings(args)
+                for s in paths:
+                    if s.startswith("/api") or s.startswith("/admin") or s.startswith("/management"):
+                        default_auth = True
+                        break
+                if default_auth:
+                    break
+
+        for mm in _MATCHERS_PERMITALL_RE.finditer(src):
+            args = mm.group(2) or ""
+            for s in _extract_strings(args):
+                permit_all.append(s)
+
+    if found_security_config and not default_auth:
+        default_auth = True
+
+    seen: set[str] = set()
+    uniq: list[str] = []
+    for pth in permit_all:
+        if pth in seen:
+            continue
+        seen.add(pth)
+        uniq.append(pth)
+
+    return default_auth, uniq
+
+
+def _is_auth_public_endpoint(path: str) -> bool:
+    return (
+        path.startswith("/auth")
+        or path.startswith("/api/authenticate")
+        or path.startswith("/api/auth/")  # strict
+        or path.startswith("/api/register")
+        or path.startswith("/api/activate")
+        or path.startswith("/api/account/reset-password")
+    )
+
+
+def _guess_access(path: str, *, default_auth: bool, permit_all: list[str]) -> str:
+    if _is_auth_public_endpoint(path):
+        return "PUBLIC"
+    if _matches_any(path, permit_all):
+        return "PUBLIC"
+    if path.startswith("/api/admin") or path.startswith("/admin"):
+        return "ADMIN"
+    if path.startswith("/me"):
+        return "CUSTOMER"
+    if default_auth:
+        return "AUTH"
+    return "PUBLIC"
+
+
+def _display_role_str(path: str, roles: set[str], *, default_auth: bool, permit_all: list[str]) -> str:
+    if _is_auth_public_endpoint(path):
+        return "{PUBLIC}"
+    if roles:
+        return "{" + ", ".join(sorted(roles)) + "}"
+    return "{" + _guess_access(path, default_auth=default_auth, permit_all=permit_all) + "}"
+
+
+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)"),
+        debug_security: bool = typer.Option(False, "--debug-security", help="Debug Spring Security detection"),
+    ):
+        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))
+
+        files_for_security = files
+        if only_main:
+            tmp: list[Path] = []
+            for f in files:
+                fp = _norm_path(str(f)).lower()
+                if "/src/test/" in fp or "/target/" in fp or "/build/" in fp:
+                    continue
+                tmp.append(f)
+            files_for_security = tmp
+
+        default_auth, permit_all = _detect_spring_security_policy(files_for_security)
+
+        if debug_security:
+            typer.echo("")
+            typer.echo("DEBUG SECURITY DETECTION")
+            typer.echo("  default_auth=" + str(default_auth))
+            typer.echo("  permit_all_count=" + str(len(permit_all)))
+            typer.echo("  security_candidates_detected=" + str(len(_LAST_SECURITY_CANDIDATES)))
+            for i, fp in enumerate(_LAST_SECURITY_CANDIDATES[:25], start=1):
+                typer.echo(f"  {i:02d}. {fp}")
+            typer.echo("")
+
+        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),
+                        default_auth=default_auth,
+                        permit_all=permit_all,
+                    )
+                )
+            elif suf == ".py":
+                all_eps.extend(extract_python_endpoints(src, str(f)))
+
+        # NEW: OpenAPI fallback (spec-first repos like spring-petclinic-rest)
+        if lang_norm in {"all", "java"}:
+            spring_count = sum(1 for e in all_eps if e.framework == "spring")
+            if spring_count == 0:
+                all_eps.extend(extract_openapi_endpoints(project_root))
+
+        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 [])
+                typer.echo(
+                    f"{e.method:6} {e.path:40} "
+                    f"{_display_role_str(e.path, roles, default_auth=default_auth, permit_all=permit_all)}  "
+                    f"{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())
+                parts.append(f"{m}{_display_role_str(p, role_set, default_auth=default_auth, permit_all=permit_all)}")
+            typer.echo(f"{idx:02d}. {p}  [{', '.join(parts)}]")

aja_codeintel-0.1.5/codeintel_cli/commands/project/frontend_cmd.py

@@ -0,0 +1,39 @@
+"""
+codeintel_cli/commands/project/frontend_cmd.py
+Registers the `aja frontend` command.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+import typer
+
+from ...errors import InvalidPathError
+from ...core.project import find_project_root
+from ...frontend.server import serve
+
+
+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 register_frontend(app: typer.Typer) -> None:
+    @app.command("frontend", help="Launch a visual UI dashboard for models, endpoints, relationships & DTOs.")
+    def frontend(
+        path: str = typer.Argument(".", help="Project root folder"),
+        port: int = typer.Option(7821, "--port", "-p", help="Port to serve the UI on"),
+    ) -> None:
+        folder = _validate_folder(path)
+        project_root = find_project_root(folder)
+
+        typer.echo("=" * 60)
+        typer.echo("  CodeIntel Frontend")
+        typer.echo("=" * 60)
+        typer.echo(f"  ROOT : {project_root}")
+        typer.echo(f"  PORT : {port}")
+        typer.echo("")
+        typer.echo("  Scanning project…")
+
+        serve(project_root, port=port)

{aja_codeintel-0.1.4 → aja_codeintel-0.1.5}/codeintel_cli/commands/project/models_cmd.py

@@ -7,47 +7,104 @@ from ...core.project import find_project_root
 from ...scanner.scanner import find_all_supported_files
 
 
+MODEL_DIRS = {
+    "model", "models",
+    "entity", "entities",
+    "domain", "domains",
+    "core",
+    "aggregate", "aggregates",
+    "persistence",
+    "db",
+    "data",
+    "schema",
+    "pojo",
+    "bean", "beans",
+    "orm",
+    "schemas",
+    "datamodel", "datamodels",
+    "table", "tables",
+    "record", "records",
+    "document", "documents",
+    "dao",
+}
+
+SKIP_DIRS = {
+    "test", "tests",
+    "controller", "controllers",
+    "service", "services",
+    "repository", "repositories",
+    "config", "configuration",
+    "util", "utils", "helper", "helpers",
+    "exception", "exceptions",
+    "security",
+    "mapper", "mappers",
+    "migration", "migrations",
+    "dto",
+}
+
+SKIP_SUFFIXES = (
+    "Repository",
+    "Mapper",
+    "Dao",
+    "Service",
+    "Controller",
+    "Config",
+    "Configuration",
+    "Util",
+    "Utils",
+    "Helper",
+    "Exception",
+    "Handler",
+    "Interceptor",
+    "Filter",
+    "Listener",
+    "Scheduler",
+    "Validator",
+    "Converter",
+    "Serializer",
+    "Deserializer",
+    "Factory",
+    "Builder",
+    "Specification",
+)
+
+
 def _import_extractors():
     py = None
     jv = None
-
     try:
-        from ...lang.python.models import extract_python_models as _py  # type: ignore
-
+        from ...lang.python.models import extract_python_models as _py
         py = _py
     except Exception:
         pass
-
     try:
-        from ...context.python_context import extract_python_models as _py  # type: ignore
-
+        from ...context.python_context import extract_python_models as _py
         py = _py
     except Exception:
         pass
-
     try:
-        from ...lang.java.models import extract_java_models as _jv  # type: ignore
-
+        from ...lang.java.models import extract_java_models as _jv
         jv = _jv
     except Exception:
         pass
-
     try:
-        from ...context.java_context import extract_java_models as _jv  # type: ignore
-
+        from ...context.java_context import extract_java_models as _jv
         jv = _jv
     except Exception:
         pass
-
     return py, jv
 
 
 def _is_model_path(rel: Path) -> bool:
-    keys = {"model", "models", "entity", "entities", "domain", "domains"}
     parts = [p.lower() for p in rel.parts]
     if "src" in parts and "test" in parts:
         return False
-    return any(part in keys for part in parts)
+    if any(part in SKIP_DIRS for part in parts):
+        return False
+    stem = rel.stem
+    if any(stem.endswith(s) for s in SKIP_SUFFIXES):
+        return False
+    return any(part in MODEL_DIRS for part in parts)
 
 
 def register_models(app: typer.Typer) -> None:
@@ -57,13 +114,12 @@ def register_models(app: typer.Typer) -> None:
     ):
         root_path = Path(root).resolve()
         project_root = find_project_root(root_path)
-
         extract_python_models, extract_java_models = _import_extractors()
-
         files = find_all_supported_files(project_root)
 
         candidates: list[Path] = []
         pr = project_root.resolve()
+
         for f in files:
             fr = f.resolve()
             try:
@@ -74,17 +130,14 @@ def register_models(app: typer.Typer) -> None:
                 candidates.append(fr)
 
         out: list[str] = []
-
         for f in sorted(candidates, key=lambda x: str(x).lower()):
             ext = f.suffix.lower()
-
             if ext == ".py" and extract_python_models is not None:
                 defs = extract_python_models(f, project_root)
             elif ext == ".java" and extract_java_models is not None:
                 defs = extract_java_models(f, project_root)
             else:
                 continue
-
             for d in defs:
                 out.append(f"{d.name}  ({d.kind})  {d.file}")
                 for fld in d.fields: