aja-codeintel 0.1.9__tar.gz → 0.2.0__tar.gz

{aja_codeintel-0.1.9 → aja_codeintel-0.2.0}/PKG-INFO

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

{aja_codeintel-0.1.9 → aja_codeintel-0.2.0}/aja_codeintel.egg-info/PKG-INFO

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

{aja_codeintel-0.1.9 → aja_codeintel-0.2.0}/aja_codeintel.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ codeintel_cli/commands/project/__init__.py
 codeintel_cli/commands/project/context_cmd.py
 codeintel_cli/commands/project/debug_cmd.py
 codeintel_cli/commands/project/endpoints_cmd.py
+codeintel_cli/commands/project/entire_cmd.py
 codeintel_cli/commands/project/errors_cmd.py
 codeintel_cli/commands/project/fastapi_cmd.py
 codeintel_cli/commands/project/folder_cmd.py
@@ -74,6 +75,7 @@ codeintel_cli/graph/query.py
 codeintel_cli/graph/traverse.py
 codeintel_cli/lang/__init__.py
 codeintel_cli/lang/router.py
+codeintel_cli/lang/shared_models.py
 codeintel_cli/lang/java/__init__.py
 codeintel_cli/lang/java/ast_engine.py
 codeintel_cli/lang/java/auth.py
@@ -98,4 +100,6 @@ codeintel_cli/scanner/scanner.py
 codeintel_cli/terminal/__init__.py
 codeintel_cli/terminal/error_parser.py
 codeintel_cli/terminal/printer.py
-tests/test_fastapi_scanner.py
+tests/test_entire_cmd.py
+tests/test_fastapi_scanner.py
+tests/test_trace_cmd.py

{aja_codeintel-0.1.9 → aja_codeintel-0.2.0}/codeintel_cli/commands/project/__init__.py

@@ -21,6 +21,7 @@ def register_project_commands(app: typer.Typer) -> None:
     from .debug_cmd import register_debug
     from .fastapi_cmd import register_fastapi_scan
     from .trace_cmd import register_trace
+    from .entire_cmd import register_entire
 
     register_overview(app)
     register_models(app)
@@ -40,3 +41,4 @@ def register_project_commands(app: typer.Typer) -> None:
     register_debug(app)
     register_fastapi_scan(app)
     register_trace(app)
+    register_entire(app)

{aja_codeintel-0.1.9 → aja_codeintel-0.2.0}/codeintel_cli/commands/project/endpoints_cmd.py

@@ -14,7 +14,7 @@ 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 ...endpoints.openapi_spec import extract_openapi_endpoints
 from ...errors import InvalidPathError
 
 

aja_codeintel-0.2.0/codeintel_cli/commands/project/entire_cmd.py

@@ -0,0 +1,417 @@
+"""
+aja entire [path]
+
+Full project intelligence report:
+  - Project tree (with .env, all files, inner functions, classes, models, DTOs)
+  - Every endpoint with FULL TRACE (import-aware, follows actual code flow)
+  - Request/Response models for each endpoint
+  - No guessing — traces through actual import chains
+
+Even 130+ endpoints — every single one gets a proper trace.
+"""
+from __future__ import annotations
+
+import ast
+import os
+import re
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ...core.project import find_project_root
+from ...endpoints.fastapi_scanner import scan_fastapi_project, _collect_python_files, PydanticDTO
+from .trace_cmd import (
+    _build_func_index,
+    _trace,
+    _render,
+    _file_role,
+    _short_path,
+    _get_ast,
+    _find_func,
+    _ast_cache,
+    FuncDef,
+    TraceNode,
+)
+
+# --------------------------------------------------------------------------- #
+# Ignore dirs
+# --------------------------------------------------------------------------- #
+
+_SKIP_DIRS = {
+    ".git", ".idea", ".vscode", "__pycache__", ".pytest_cache",
+    ".ruff_cache", ".tox", ".venv", "venv", "env",
+    "node_modules", "dist", "build", "out", "target", ".gradle",
+}
+
+# --------------------------------------------------------------------------- #
+# Tree: show .env, all source files with classes/functions inside
+# --------------------------------------------------------------------------- #
+
+def _walk_source_files(root: Path) -> list[Path]:
+    """Walk project and collect all .py files, .env, config files."""
+    files: list[Path] = []
+    stack = [root.resolve()]
+    while stack:
+        cur = stack.pop()
+        try:
+            for child in sorted(cur.iterdir(), key=lambda p: (p.is_file(), p.name.lower())):
+                if child.is_dir():
+                    if child.name not in _SKIP_DIRS:
+                        stack.append(child)
+                elif child.suffix in (".py", ".env", ".toml", ".yaml", ".yml", ".cfg", ".ini", ".json"):
+                    files.append(child)
+                elif child.name in (".env", ".env.example", ".env.local", "Dockerfile", "docker-compose.yml"):
+                    files.append(child)
+        except (PermissionError, FileNotFoundError):
+            continue
+    return files
+
+
+def _extract_file_symbols(path: Path) -> dict:
+    """
+    Extract classes (with methods/fields) and top-level functions from a .py file.
+    Returns: { "classes": [...], "functions": [...] }
+    """
+    result = {"classes": [], "functions": []}
+    try:
+        src = path.read_text(encoding="utf-8", errors="ignore")
+        tree = ast.parse(src)
+    except Exception:
+        return result
+
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            params = []
+            for arg in node.args.args:
+                if arg.arg == "self":
+                    continue
+                ann = ast.unparse(arg.annotation) if arg.annotation else "Any"
+                params.append(f"{arg.arg}: {ann}")
+            ret = ast.unparse(node.returns) if node.returns else "None"
+            result["functions"].append({
+                "name": node.name,
+                "params": params,
+                "return": ret,
+                "line": node.lineno,
+            })
+        elif isinstance(node, ast.ClassDef):
+            cls_info = {
+                "name": node.name,
+                "bases": [ast.unparse(b) for b in node.bases],
+                "methods": [],
+                "fields": [],
+                "line": node.lineno,
+            }
+            for item in node.body:
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    params = []
+                    for arg in item.args.args:
+                        if arg.arg == "self":
+                            continue
+                        ann = ast.unparse(arg.annotation) if arg.annotation else "Any"
+                        params.append(f"{arg.arg}: {ann}")
+                    ret = ast.unparse(item.returns) if item.returns else "None"
+                    cls_info["methods"].append({
+                        "name": item.name,
+                        "params": params,
+                        "return": ret,
+                        "line": item.lineno,
+                    })
+                elif isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
+                    field_type = ast.unparse(item.annotation) if item.annotation else "Any"
+                    cls_info["fields"].append({
+                        "name": item.target.id,
+                        "type": field_type,
+                    })
+            result["classes"].append(cls_info)
+
+    return result
+
+
+def _print_project_tree(project_root: Path) -> None:
+    """Print project tree with .env files and all source files showing inner structure."""
+    typer.echo("=" * 70)
+    typer.echo("  PROJECT TREE (with classes, functions, models)")
+    typer.echo("=" * 70)
+    typer.echo(f"  ROOT: {project_root}")
+    typer.echo("")
+
+    # Show .env files first
+    env_files = []
+    for pattern in (".env", ".env.example", ".env.local", ".env.development", ".env.production"):
+        f = project_root / pattern
+        if f.exists():
+            env_files.append(f)
+
+    if env_files:
+        typer.echo("  ╔══ ENVIRONMENT FILES")
+        for ef in env_files:
+            typer.echo(f"  ║  {ef.name}")
+            try:
+                lines = ef.read_text(encoding="utf-8", errors="ignore").splitlines()
+                for line in lines:
+                    line = line.strip()
+                    if not line or line.startswith("#"):
+                        continue
+                    # Show key but mask sensitive values
+                    if "=" in line:
+                        key = line.split("=", 1)[0].strip()
+                        typer.echo(f"  ║    {key}=***")
+                    else:
+                        typer.echo(f"  ║    {line}")
+            except Exception:
+                pass
+        typer.echo("  ╚══")
+        typer.echo("")
+
+    # Walk and show source structure
+    def _walk_tree(cur: Path, prefix: str = "", depth: int = 0, max_depth: int = 10) -> None:
+        if depth > max_depth:
+            return
+        try:
+            entries = sorted(cur.iterdir(), key=lambda p: (p.is_file(), p.name.lower()))
+        except (PermissionError, FileNotFoundError):
+            return
+
+        visible = []
+        for e in entries:
+            if e.name in _SKIP_DIRS:
+                continue
+            if e.is_dir():
+                visible.append(e)
+            elif e.suffix in (".py",) or e.name in (".env",):
+                visible.append(e)
+
+        for i, entry in enumerate(visible):
+            is_last = i == len(visible) - 1
+            branch = "└── " if is_last else "├── "
+            child_prefix = prefix + ("    " if is_last else "│   ")
+
+            if entry.is_dir():
+                typer.echo(f"  {prefix}{branch}{entry.name}/")
+                _walk_tree(entry, child_prefix, depth + 1, max_depth)
+            else:
+                typer.echo(f"  {prefix}{branch}{entry.name}")
+                # Show inner structure for .py files
+                if entry.suffix == ".py":
+                    symbols = _extract_file_symbols(entry)
+                    inner_items = []
+                    for cls in symbols["classes"]:
+                        bases = f"({', '.join(cls['bases'])})" if cls['bases'] else ""
+                        inner_items.append(("class", f"{cls['name']}{bases}", cls))
+                    for fn in symbols["functions"]:
+                        inner_items.append(("func", f"{fn['name']}()", fn))
+
+                    for j, (kind, label, info) in enumerate(inner_items):
+                        is_inner_last = j == len(inner_items) - 1
+                        inner_branch = "└─ " if is_inner_last else "├─ "
+                        inner_prefix = child_prefix + ("   " if is_inner_last else "│  ")
+
+                        if kind == "class":
+                            typer.echo(f"  {child_prefix}{inner_branch}class {label}")
+                            # Show fields and methods
+                            members = []
+                            for fld in info.get("fields", []):
+                                members.append(f"{fld['name']}: {fld['type']}")
+                            for meth in info.get("methods", []):
+                                members.append(f"{meth['name']}()")
+                            for k, mem in enumerate(members[:15]):  # limit to 15
+                                mem_last = k == len(members[:15]) - 1
+                                mem_branch = "└─ " if mem_last else "├─ "
+                                typer.echo(f"  {inner_prefix}{mem_branch}{mem}")
+                        else:
+                            typer.echo(f"  {child_prefix}{inner_branch}def {label}")
+
+    _walk_tree(project_root)
+    typer.echo("")
+
+
+# --------------------------------------------------------------------------- #
+# DTO / Model display helpers
+# --------------------------------------------------------------------------- #
+
+def _format_dto(dto: PydanticDTO, indent: str = "    ") -> list[str]:
+    """Format a Pydantic DTO with all fields."""
+    lines = []
+    bases = f"({', '.join(dto.bases)})" if dto.bases else ""
+    lines.append(f"{indent}{dto.name}{bases}")
+    for f in dto.fields:
+        req = "*" if f.required else " "
+        default = f" = {f.default}" if f.default else ""
+        lines.append(f"{indent}  {req} {f.name}: {f.type}{default}")
+    return lines
+
+
+# --------------------------------------------------------------------------- #
+# ENTIRE command: traces every endpoint
+# --------------------------------------------------------------------------- #
+
+def register_entire(app: typer.Typer) -> None:
+    @app.command("entire", help="Full project report: tree + every endpoint traced with request/response.")
+    def entire(
+        path: str = typer.Argument(".", help="Project root folder"),
+        depth: int = typer.Option(6, "--depth", "-d", help="Max trace depth per endpoint"),
+        no_tree: bool = typer.Option(False, "--no-tree", help="Skip project tree section"),
+    ) -> None:
+        _ast_cache.clear()
+        t0 = time.perf_counter()
+
+        folder = Path(path).resolve()
+        if not folder.exists() or not folder.is_dir():
+            typer.echo(f"  Invalid folder: {folder}")
+            raise typer.Exit(1)
+
+        project_root = find_project_root(folder)
+
+        # ── 1. Project Tree ────────────────────────────────────────────
+        if not no_tree:
+            _print_project_tree(project_root)
+
+        # ── 2. Scan all endpoints and models ───────────────────────────
+        all_py = _collect_python_files(project_root, _SKIP_DIRS)
+        endpoints, pydantic_dtos, sqla_models, request_models, response_models, endpoint_deps = \
+            scan_fastapi_project(project_root, files=all_py)
+
+        # Build indexes
+        func_index = _build_func_index(all_py)
+
+        # DTO lookup by name
+        dto_by_name: dict[str, PydanticDTO] = {d.name: d for d in pydantic_dtos}
+
+        # De-duplicate endpoints
+        seen_keys: set[tuple[str, str]] = set()
+        unique_endpoints = []
+        for e in endpoints:
+            k = (e.method, e.path)
+            if k not in seen_keys:
+                seen_keys.add(k)
+                unique_endpoints.append(e)
+        unique_endpoints.sort(key=lambda e: (e.path, e.method))
+
+        # ── 3. MODELS / DTOs Section ──────────────────────────────────
+        typer.echo("=" * 70)
+        typer.echo("  MODELS & DTOs")
+        typer.echo("=" * 70)
+        typer.echo("")
+
+        if sqla_models:
+            typer.echo("  ── SQLAlchemy Models ──")
+            for m in sqla_models:
+                typer.echo(f"    {m.name}  (table: {m.table_name})  {m.file}")
+                for col in m.columns:
+                    pk = " [PK]" if col.primary_key else ""
+                    fk = f" [FK→{col.foreign_key}]" if col.foreign_key else ""
+                    typer.echo(f"      {col.name}: {col.col_type}{pk}{fk}")
+                for rel in m.relationships:
+                    typer.echo(f"      →{rel.name}: {rel.target}")
+            typer.echo("")
+
+        if pydantic_dtos:
+            # Classify
+            req_dtos = [d for d in pydantic_dtos if d.name in request_models and d.name not in response_models]
+            res_dtos = [d for d in pydantic_dtos if d.name in response_models and d.name not in request_models]
+            both_dtos = [d for d in pydantic_dtos if d.name in request_models and d.name in response_models]
+            other_dtos = [d for d in pydantic_dtos if d.name not in request_models and d.name not in response_models]
+
+            for label, group in [("REQUEST DTOs", req_dtos), ("RESPONSE DTOs", res_dtos),
+                                 ("REQUEST+RESPONSE", both_dtos), ("SHARED/CONFIG", other_dtos)]:
+                if not group:
+                    continue
+                typer.echo(f"  ── {label} ({len(group)}) ──")
+                for dto in group:
+                    for line in _format_dto(dto):
+                        typer.echo(line)
+                typer.echo("")
+
+        # ── 4. ENDPOINT TRACES ────────────────────────────────────────
+        typer.echo("=" * 70)
+        typer.echo(f"  ENDPOINT TRACES ({len(unique_endpoints)} endpoints)")
+        typer.echo("=" * 70)
+        typer.echo("")
+
+        for idx, ep in enumerate(unique_endpoints, 1):
+            handler_name = ep.handler
+            handler_file = Path(ep.file)
+
+            typer.echo(f"  {'━' * 66}")
+            typer.echo(f"  [{idx:03d}]  {ep.method}  {ep.path}")
+            typer.echo(f"  {'━' * 66}")
+            typer.echo(f"  Handler : {handler_name}()  ·  {_short_path(handler_file, project_root)}")
+
+            # Show request/response models for this endpoint
+            req_model = getattr(ep, 'request_body', None) or None
+            resp_model = getattr(ep, 'response_model', None) or None
+
+            if req_model:
+                typer.echo(f"  Request : {req_model}")
+                if req_model in dto_by_name:
+                    dto = dto_by_name[req_model]
+                    for f in dto.fields:
+                        req_mark = "*" if f.required else " "
+                        typer.echo(f"            {req_mark} {f.name}: {f.type}")
+
+            if resp_model:
+                typer.echo(f"  Response: {resp_model}")
+                # Try to resolve the actual type (strip list[], Optional[], etc.)
+                inner = re.sub(r"^(?:list|List)\[(.+)\]$", r"\1", resp_model)
+                inner = re.sub(r"^Optional\[(.+)\]$", r"\1", inner)
+                if inner in dto_by_name:
+                    dto = dto_by_name[inner]
+                    for f in dto.fields:
+                        typer.echo(f"            {f.name}: {f.type}")
+
+            # Show dependencies
+            ep_deps = None
+            for dep_item in endpoint_deps:
+                if dep_item["method"] == ep.method and dep_item["path"] == ep.path:
+                    ep_deps = dep_item["depends"]
+                    break
+            if ep_deps:
+                typer.echo(f"  Depends : {', '.join(ep_deps)}")
+
+            # Trace the call chain
+            tree = _get_ast(handler_file)
+            if tree is None:
+                typer.echo(f"  ⚠ Could not parse {handler_file.name}")
+                typer.echo("")
+                continue
+
+            handler_node = _find_func(tree, handler_name)
+            if handler_node is None:
+                typer.echo(f"  ⚠ Function '{handler_name}' not found in {handler_file.name}")
+                typer.echo("")
+                continue
+
+            visited: set[tuple[str, str]] = set()
+            root_node = _trace(handler_node, handler_file, func_index, project_root,
+                               visited, depth=0, max_depth=depth)
+
+            typer.echo(f"  Call chain:")
+            typer.echo(f"    {handler_name}()")
+            child_prefix = "    "
+            for i, child in enumerate(root_node.calls):
+                for line in _render(child, project_root, child_prefix, i == len(root_node.calls) - 1):
+                    typer.echo(line)
+
+            if root_node.unresolved:
+                typer.echo(f"  Unresolved: {', '.join(root_node.unresolved)}")
+
+            typer.echo("")
+
+        # ── 5. Summary ────────────────────────────────────────────────
+        elapsed = time.perf_counter() - t0
+        typer.echo("=" * 70)
+        typer.echo(f"  SUMMARY")
+        typer.echo("=" * 70)
+        typer.echo(f"  Total endpoints   : {len(unique_endpoints)}")
+        typer.echo(f"  Total DTOs        : {len(pydantic_dtos)}")
+        typer.echo(f"  Request models    : {len(request_models)}")
+        typer.echo(f"  Response models   : {len(response_models)}")
+        typer.echo(f"  SQLAlchemy models : {len(sqla_models)}")
+        typer.echo(f"  Python files      : {len(all_py)}")
+        typer.echo(f"  Finished in       : {elapsed:.2f}s")
+        typer.echo("")