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

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

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

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

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

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

@@ -0,0 +1,639 @@
+"""
+aja entire [path]
+
+Full project intelligence report — NOT just names, but actual shapes:
+  - Function SIGNATURES (params + return types)
+  - Model/Schema DEFINITIONS (all Pydantic fields, types, defaults)
+  - Cosmos DB / database QUERY PATTERNS extracted from source
+  - Route definitions with full request/response shapes
+  - Import-aware call chain traces for every endpoint
+
+Designed to produce an actionable prompt without needing to read individual files.
+"""
+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",
+}
+
+# --------------------------------------------------------------------------- #
+# Source file walking
+# --------------------------------------------------------------------------- #
+
+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
+
+
+# --------------------------------------------------------------------------- #
+# Extract full function signatures (not just names)
+# --------------------------------------------------------------------------- #
+
+def _extract_file_symbols(path: Path) -> dict:
+    """
+    Extract classes (with methods+fields) and top-level functions with
+    FULL SIGNATURES (params, types, return types, defaults).
+    """
+    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)):
+            result["functions"].append(_extract_func_sig(node))
+        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)):
+                    cls_info["methods"].append(_extract_func_sig(item))
+                elif isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
+                    field_type = ast.unparse(item.annotation) if item.annotation else "Any"
+                    default_val = ast.unparse(item.value) if item.value else None
+                    cls_info["fields"].append({
+                        "name": item.target.id,
+                        "type": field_type,
+                        "default": default_val,
+                    })
+            result["classes"].append(cls_info)
+
+    return result
+
+
+def _extract_func_sig(node: ast.FunctionDef) -> dict:
+    """Extract full function signature: name, params with types+defaults, return type."""
+    params = []
+    args = node.args
+
+    # Positional args
+    n_defaults = len(args.defaults)
+    n_args = len(args.args)
+    for i, arg in enumerate(args.args):
+        if arg.arg == "self" or arg.arg == "cls":
+            continue
+        ann = ast.unparse(arg.annotation) if arg.annotation else None
+        # Check if this arg has a default
+        default_idx = i - (n_args - n_defaults)
+        default_val = None
+        if default_idx >= 0:
+            default_val = ast.unparse(args.defaults[default_idx])
+        param_str = arg.arg
+        if ann:
+            param_str += f": {ann}"
+        if default_val:
+            param_str += f" = {default_val}"
+        params.append(param_str)
+
+    # Keyword-only args
+    for arg, default in zip(args.kwonlyargs, args.kw_defaults):
+        ann = ast.unparse(arg.annotation) if arg.annotation else None
+        default_val = ast.unparse(default) if default else None
+        param_str = arg.arg
+        if ann:
+            param_str += f": {ann}"
+        if default_val:
+            param_str += f" = {default_val}"
+        params.append(param_str)
+
+    ret = ast.unparse(node.returns) if node.returns else None
+    is_async = isinstance(node, ast.AsyncFunctionDef)
+
+    return {
+        "name": node.name,
+        "params": params,
+        "return": ret,
+        "line": node.lineno,
+        "async": is_async,
+    }
+
+
+# --------------------------------------------------------------------------- #
+# Cosmos DB / Database query pattern extraction
+# --------------------------------------------------------------------------- #
+
+_COSMOS_QUERY_RE = re.compile(
+    r"""(?:query_items|query|read_all_items|read_item|create_item|upsert_item|"""
+    r"""replace_item|delete_item|patch_item)\s*\(""",
+    re.IGNORECASE,
+)
+
+_SQL_QUERY_RE = re.compile(
+    r"""SELECT\s+.+?\s+FROM\s+\w+""",
+    re.IGNORECASE | re.DOTALL,
+)
+
+
+@dataclass
+class QueryPattern:
+    file: str
+    line: int
+    operation: str     # "query_items", "upsert_item", etc.
+    query_text: str    # the SQL/query string if found
+    container: str     # container name if detectable
+    function: str      # enclosing function name
+
+
+def _extract_query_patterns(all_py: list[Path], project_root: Path) -> list[QueryPattern]:
+    """
+    Extract actual database query patterns from source files.
+    Looks for Cosmos DB SDK calls AND embedded SQL strings.
+    """
+    patterns: list[QueryPattern] = []
+
+    # Cosmos SDK operations
+    cosmos_ops_re = re.compile(
+        r"""(query_items|read_all_items|read_item|create_item|"""
+        r"""upsert_item|replace_item|delete_item|patch_item)\s*\(""",
+    )
+    # SQL query strings
+    sql_str_re = re.compile(
+        r"""['"](SELECT\s+.+?FROM\s+\w+[^'"]*?)['"]""",
+        re.IGNORECASE | re.DOTALL,
+    )
+    # Container references
+    container_re = re.compile(
+        r"""get_container_client\s*\(\s*['"]([\w-]+)['"]\)"""
+        r"""|container_name\s*=\s*['"]([\w-]+)['"]"""
+        r"""|CONTAINER(?:_NAME)?\s*=\s*['"]([\w-]+)['"]""",
+        re.IGNORECASE,
+    )
+
+    for path in all_py:
+        parts_lower = {p.lower() for p in path.parts}
+        if parts_lower & {"test", "tests"}:
+            continue
+        try:
+            src = path.read_text(encoding="utf-8", errors="ignore")
+        except Exception:
+            continue
+
+        if not (cosmos_ops_re.search(src) or sql_str_re.search(src)):
+            continue
+
+        rel = _short_path(path, project_root, parts=4)
+
+        # Find container name in this file
+        container = ""
+        cm = container_re.search(src)
+        if cm:
+            container = cm.group(1) or cm.group(2) or cm.group(3) or ""
+
+        # Parse to find which function each query is in
+        try:
+            tree = ast.parse(src)
+        except Exception:
+            continue
+
+        lines = src.splitlines()
+        # Index: line_number -> enclosing function name
+        func_ranges: list[tuple[int, int, str]] = []
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                end = getattr(node, 'end_lineno', node.lineno + 50)
+                func_ranges.append((node.lineno, end, node.name))
+
+        def _enclosing_func(lineno: int) -> str:
+            for start, end, name in func_ranges:
+                if start <= lineno <= end:
+                    return name
+            return "<module>"
+
+        # Extract Cosmos operations
+        for m in cosmos_ops_re.finditer(src):
+            lineno = src[:m.start()].count('\n') + 1
+            op = m.group(1)
+            # Try to grab the query string argument
+            query_str = ""
+            # Look for a SQL string in nearby lines (within 5 lines)
+            start_line = max(0, lineno - 1)
+            end_line = min(len(lines), lineno + 5)
+            snippet = "\n".join(lines[start_line:end_line])
+            sql_m = sql_str_re.search(snippet)
+            if sql_m:
+                query_str = sql_m.group(1).strip()
+
+            patterns.append(QueryPattern(
+                file=rel, line=lineno, operation=op,
+                query_text=query_str, container=container,
+                function=_enclosing_func(lineno),
+            ))
+
+        # Extract standalone SQL strings not already captured
+        for m in sql_str_re.finditer(src):
+            lineno = src[:m.start()].count('\n') + 1
+            # Skip if already captured by cosmos ops
+            already = any(p.line == lineno and p.file == rel for p in patterns)
+            if already:
+                continue
+            patterns.append(QueryPattern(
+                file=rel, line=lineno, operation="SQL_QUERY",
+                query_text=m.group(1).strip(), container=container,
+                function=_enclosing_func(lineno),
+            ))
+
+    return patterns
+
+
+# --------------------------------------------------------------------------- #
+# Tree: show signatures, not just names
+# --------------------------------------------------------------------------- #
+
+def _print_project_tree(project_root: Path) -> None:
+    """Print project tree with full function signatures and model fields."""
+    typer.echo("=" * 70)
+    typer.echo("  PROJECT STRUCTURE (signatures + schemas)")
+    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
+                    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("")
+
+    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}")
+                if entry.suffix == ".py":
+                    symbols = _extract_file_symbols(entry)
+                    inner_items = []
+                    for cls in symbols["classes"]:
+                        inner_items.append(("class", cls))
+                    for fn in symbols["functions"]:
+                        inner_items.append(("func", fn))
+
+                    for j, (kind, 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":
+                            bases = f"({', '.join(info['bases'])})" if info['bases'] else ""
+                            typer.echo(f"  {child_prefix}{inner_branch}class {info['name']}{bases}")
+                            # Show fields with types and defaults
+                            members = []
+                            for fld in info.get("fields", []):
+                                default_str = f" = {fld['default']}" if fld.get('default') else ""
+                                members.append(("field", f"{fld['name']}: {fld['type']}{default_str}"))
+                            for meth in info.get("methods", []):
+                                sig = _format_sig(meth)
+                                members.append(("method", sig))
+                            for k, (mtype, mem) in enumerate(members[:20]):
+                                mem_last = k == len(members[:20]) - 1
+                                mem_branch = "└─ " if mem_last else "├─ "
+                                typer.echo(f"  {inner_prefix}{mem_branch}{mem}")
+                            if len(members) > 20:
+                                typer.echo(f"  {inner_prefix}   ... +{len(members)-20} more")
+                        else:
+                            sig = _format_sig(info)
+                            typer.echo(f"  {child_prefix}{inner_branch}{sig}")
+
+    _walk_tree(project_root)
+    typer.echo("")
+
+
+def _format_sig(info: dict) -> str:
+    """Format a function signature compactly: async def name(params) -> ReturnType"""
+    prefix = "async def " if info.get("async") else "def "
+    params_str = ", ".join(info["params"]) if info["params"] else ""
+    ret = f" -> {info['return']}" if info.get("return") else ""
+    return f"{prefix}{info['name']}({params_str}){ret}"
+
+
+# --------------------------------------------------------------------------- #
+# 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
+# --------------------------------------------------------------------------- #
+
+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. 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_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))
+
+        # ── 2. Project Tree (with full signatures) ─────────────────────
+        if not no_tree:
+            _print_project_tree(project_root)
+
+        # ── 3. SCHEMA DEFINITIONS ─────────────────────────────────────
+        typer.echo("=" * 70)
+        typer.echo("  SCHEMA DEFINITIONS (Pydantic models — the data shapes)")
+        typer.echo("=" * 70)
+        typer.echo("")
+
+        if pydantic_dtos:
+            # Classify by usage
+            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 SCHEMAS", req_dtos), ("RESPONSE SCHEMAS", res_dtos),
+                                 ("REQUEST+RESPONSE", both_dtos), ("SHARED/DOMAIN MODELS", 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("")
+        else:
+            typer.echo("  No Pydantic models found.")
+            typer.echo("")
+
+        if sqla_models:
+            typer.echo("  ── ORM / 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("")
+
+        # ── 4. DATABASE QUERY PATTERNS ────────────────────────────────
+        query_patterns = _extract_query_patterns(all_py, project_root)
+        if query_patterns:
+            typer.echo("=" * 70)
+            typer.echo("  DATABASE QUERY PATTERNS")
+            typer.echo("=" * 70)
+            typer.echo("")
+
+            # Group by container
+            by_container: dict[str, list[QueryPattern]] = defaultdict(list)
+            for qp in query_patterns:
+                key = qp.container or "(unknown container)"
+                by_container[key].append(qp)
+
+            for container, qps in sorted(by_container.items()):
+                typer.echo(f"  Container: {container}")
+                for qp in qps:
+                    query_display = ""
+                    if qp.query_text:
+                        # Compact multiline queries to single line
+                        q = re.sub(r'\s+', ' ', qp.query_text).strip()
+                        query_display = f'  → "{q}"'
+                    typer.echo(f"    {qp.operation}  in {qp.function}()  ({qp.file}:{qp.line}){query_display}")
+                typer.echo("")
+
+        # ── 5. ROUTE DEFINITIONS WITH SHAPES ──────────────────────────
+        typer.echo("=" * 70)
+        typer.echo(f"  ROUTE DEFINITIONS ({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)
+
+            # Get handler signature
+            tree = _get_ast(handler_file)
+            handler_sig = ""
+            handler_params = []
+            if tree:
+                handler_node = _find_func(tree, handler_name)
+                if handler_node:
+                    sig_info = _extract_func_sig(handler_node)
+                    handler_sig = _format_sig(sig_info)
+                    handler_params = sig_info["params"]
+
+            typer.echo(f"  {'━' * 66}")
+            typer.echo(f"  [{idx:03d}]  {ep.method}  {ep.path}")
+            typer.echo(f"         {handler_sig}")
+            typer.echo(f"         file: {_short_path(handler_file, project_root)}")
+
+            # Request shape
+            req_model = getattr(ep, 'request_body', 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 "?" 
+                        default_str = f" = {f.default}" if f.default else ""
+                        typer.echo(f"         │    {req_mark} {f.name}: {f.type}{default_str}")
+                typer.echo(f"         └─")
+
+            # Response shape
+            resp_model = getattr(ep, 'response_model', None) or None
+            if resp_model:
+                typer.echo(f"         ┌─ RESPONSE: {resp_model}")
+                inner = re.sub(r"^(?:list|List)\[(.+)\]$", r"\1", resp_model)
+                inner = re.sub(r"^Optional\[(.+)\]$", r"\1", inner)
+                is_list = inner != resp_model and ("list" in resp_model.lower() or "List" in resp_model)
+                if is_list:
+                    typer.echo(f"         │    (returns a list of:)")
+                if inner in dto_by_name:
+                    dto = dto_by_name[inner]
+                    for f in dto.fields:
+                        typer.echo(f"         │    {f.name}: {f.type}")
+                typer.echo(f"         └─")
+
+            # 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)}")
+
+            typer.echo("")
+
+        # ── 6. ENDPOINT CALL TRACES ───────────────────────────────────
+        typer.echo("=" * 70)
+        typer.echo(f"  ENDPOINT CALL 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)
+
+            tree = _get_ast(handler_file)
+            if tree is None:
+                typer.echo(f"  [{idx:03d}] {ep.method} {ep.path} — ⚠ could not parse")
+                continue
+
+            handler_node = _find_func(tree, handler_name)
+            if handler_node is None:
+                typer.echo(f"  [{idx:03d}] {ep.method} {ep.path} — ⚠ handler not found")
+                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"  [{idx:03d}] {ep.method} {ep.path}")
+            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("")
+
+        # ── 7. 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"  Schema definitions  : {len(pydantic_dtos)}")
+        typer.echo(f"  Request schemas     : {len(request_models)}")
+        typer.echo(f"  Response schemas    : {len(response_models)}")
+        typer.echo(f"  ORM models          : {len(sqla_models)}")
+        typer.echo(f"  DB query patterns   : {len(query_patterns)}")
+        typer.echo(f"  Python files        : {len(all_py)}")
+        typer.echo(f"  Finished in         : {elapsed:.2f}s")
+        typer.echo("")

{aja_codeintel-0.2.0 → aja_codeintel-0.2.1}/pyproject.toml

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

{aja_codeintel-0.2.0 → aja_codeintel-0.2.1}/tests/test_entire_cmd.py

@@ -172,7 +172,7 @@ class TestEntireCommand:
         result = runner.invoke(cli_app, ["entire", str(tmp_path), "--no-tree"])
         # Should not crash
         assert result.exit_code == 0
-        assert "ENDPOINT TRACES" in result.output
+        assert "ENDPOINT CALL TRACES" in result.output
         assert "/health" in result.output
 
     def test_shows_request_response_models(self, tmp_path):