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

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

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

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

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

{aja_codeintel-0.1.2 → aja_codeintel-0.1.3}/aja_codeintel.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ codeintel_cli/commands/project/resolve_cmd.py
 codeintel_cli/commands/project/scan_cmd.py
 codeintel_cli/commands/project/servicemap_cmd.py
 codeintel_cli/commands/project/tree_cmd.py
+codeintel_cli/commands/project/types_cmd.py
 codeintel_cli/commands/project/version_cmd.py
 codeintel_cli/context/java_context.py
 codeintel_cli/context/java_rel.py

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

@@ -12,6 +12,7 @@ from .modeltree_cmd import register_modeltree
 from .models_cmd import register_models
 from .servicemap_cmd import register_servicemap
 from .endpoints_cmd import register_endpoints
+from .types_cmd import register_types_command
 
 def register_project_commands(app: typer.Typer) -> None:
     register_scan(app)
@@ -24,4 +25,5 @@ def register_project_commands(app: typer.Typer) -> None:
     register_modeltree(app)
     register_models(app)
     register_servicemap(app)
-    register_endpoints(app)
+    register_endpoints(app)
+    register_types_command(app)

aja_codeintel-0.1.3/codeintel_cli/commands/project/types_cmd.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable, Optional, Tuple, Any
+import re
+import typer
+
+IGNORE_DIRS = {
+    ".git", ".idea", ".vscode", ".mvn",
+    "__pycache__", ".pytest_cache", ".ruff_cache", ".tox",
+    ".venv", "venv", "env",
+    "node_modules", "dist", "build", "out", "target", ".gradle",
+}
+
+PY_MARKERS = {"dto", "schema", "schemas", "model", "models", "types"}
+
+REQ_KEYS = ("request", "create", "update", "input", "payload", "command")
+RES_KEYS = ("response", "result", "output", "view")
+
+
+# ----------------- file walking -----------------
+def _walk_files(root: Path) -> Iterable[Path]:
+    stack = [root]
+    while stack:
+        cur = stack.pop()
+        try:
+            for child in cur.iterdir():
+                if child.is_dir():
+                    if child.name not in IGNORE_DIRS:
+                        stack.append(child)
+                else:
+                    yield child
+        except (PermissionError, FileNotFoundError):
+            continue
+
+
+def _is_java_dto(p: Path) -> bool:
+    if p.suffix != ".java":
+        return False
+    parts = [x.lower() for x in p.parts]
+    # include auth/dto and dto/request dto/response etc.
+    return "dto" in parts
+
+
+def _is_python_dto_like(p: Path) -> bool:
+    if p.suffix != ".py":
+        return False
+    parts = {part.lower() for part in p.parts}
+    return any(m in parts for m in PY_MARKERS)
+
+
+def _rel(p: Path, root: Path) -> str:
+    try:
+        return str(p.relative_to(root))
+    except ValueError:
+        return str(p)
+
+
+def _read_text_limited(p: Path, max_kb: int = 256) -> str:
+    try:
+        raw = p.read_bytes()
+    except Exception:
+        return ""
+    raw = raw[: max_kb * 1024]
+    return raw.decode("utf-8", errors="replace")
+
+
+# ----------------- classification -----------------
+def _classify_java(rel_path: str, type_name: str) -> str:
+    r = rel_path.lower().replace("\\", "/")
+    n = type_name.lower()
+
+    # folder-based classification is most reliable in your repo
+    if "/dto/request/" in r or r.endswith("/request") or "/request/" in r:
+        return "request"
+    if "/dto/response/" in r or r.endswith("/response") or "/response/" in r:
+        return "response"
+
+    # name heuristics as fallback
+    if any(k in n for k in REQ_KEYS):
+        return "request"
+    if any(k in n for k in RES_KEYS) or "response" in n:
+        return "response"
+    return "other"
+
+
+# ----------------- java parsing -----------------
+_record_re = re.compile(
+    r"\brecord\s+([A-Za-z_][A-Za-z0-9_]*)\s*\((.*?)\)\s*\{",
+    re.S,
+)
+
+_class_re = re.compile(
+    r"\b(class|record)\s+([A-Za-z_][A-Za-z0-9_]*)\b"
+)
+
+_field_re = re.compile(
+    # optional annotations lines handled separately; this matches actual field line
+    r"^\s*(public|protected|private)?\s*(static\s+)?(final\s+)?([A-Za-z_][\w\<\>\[\]\., ?]+)\s+([A-Za-z_]\w*)\s*(=.*)?;",
+    re.M,
+)
+
+_annotation_token_re = re.compile(r"^@\w+(\(.*\))?$")
+
+
+def _strip_java_annotations_from_type(type_tokens: list[str]) -> list[str]:
+    # remove leading annotation tokens like @NotBlank, @Email, @Size(...)
+    out = []
+    for t in type_tokens:
+        if _annotation_token_re.match(t.strip()):
+            continue
+        out.append(t)
+    return out
+
+
+def _parse_java_record(src: str) -> Optional[Tuple[str, list[str]]]:
+    m = _record_re.search(src)
+    if not m:
+        return None
+    name = m.group(1)
+    params = m.group(2).strip()
+    if not params:
+        return (name, [])
+
+    # split by commas (naive but ok for typical DTO params)
+    parts = []
+    buf = []
+    depth_angle = 0
+    depth_paren = 0
+    for ch in params:
+        if ch == "<":
+            depth_angle += 1
+        elif ch == ">":
+            depth_angle = max(0, depth_angle - 1)
+        elif ch == "(":
+            depth_paren += 1
+        elif ch == ")":
+            depth_paren = max(0, depth_paren - 1)
+
+        if ch == "," and depth_angle == 0 and depth_paren == 0:
+            parts.append("".join(buf).strip())
+            buf = []
+        else:
+            buf.append(ch)
+    if buf:
+        parts.append("".join(buf).strip())
+
+    fields: list[str] = []
+    for part in parts:
+        tokens = part.split()
+        if len(tokens) >= 2:
+            fname = tokens[-1].strip()
+            ftype_tokens = _strip_java_annotations_from_type(tokens[:-1])
+            ftype = " ".join(ftype_tokens).strip() or "?"
+            fields.append(f"{fname}:{ftype}")
+        else:
+            fields.append(part)
+
+    return (name, fields)
+
+
+def _parse_java_class_fields(src: str) -> Optional[Tuple[str, list[str]]]:
+    # Find first class name (good enough for DTO files)
+    cm = _class_re.search(src)
+    if not cm:
+        return None
+    kind = cm.group(1)
+    name = cm.group(2)
+    if kind == "record":
+        # record handled elsewhere
+        return None
+
+    fields: list[str] = []
+    for m in _field_re.finditer(src):
+        is_static = m.group(2) is not None
+        if is_static:
+            continue
+
+        ftype = (m.group(4) or "").strip()
+        fname = (m.group(5) or "").strip()
+
+        # cleanup type
+        ftype = re.sub(r"\s+", " ", ftype)
+        ftype = ftype.replace(" ?", "?")  # tiny cleanup
+
+        if fname and ftype:
+            fields.append(f"{fname}:{ftype}")
+
+    # de-duplicate while preserving order
+    seen = set()
+    uniq = []
+    for f in fields:
+        if f not in seen:
+            seen.add(f)
+            uniq.append(f)
+
+    return (name, uniq)
+
+
+# ----------------- python parsing (optional, kept) -----------------
+def _parse_python_dataclasses(src: str) -> list[Tuple[str, list[str]]]:
+    out: list[Tuple[str, list[str]]] = []
+    lines = src.splitlines()
+
+    i = 0
+    while i < len(lines):
+        if lines[i].strip().startswith("@dataclass"):
+            j = i + 1
+            while j < len(lines) and "class " not in lines[j]:
+                j += 1
+            if j >= len(lines):
+                break
+            cm = re.match(r"\s*class\s+([A-Za-z_][A-Za-z0-9_]*)\s*[:\(]", lines[j])
+            if not cm:
+                i = j + 1
+                continue
+
+            name = cm.group(1)
+
+            k = j + 1
+            fields: list[str] = []
+            while k < len(lines):
+                raw = lines[k]
+                if raw.strip() == "":
+                    k += 1
+                    continue
+                if not raw.startswith(" ") and not raw.startswith("\t"):
+                    break
+
+                s = raw.strip()
+                fm = re.match(r"([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^=]+?)(\s*=\s*(.+))?$", s)
+                if fm:
+                    fname = fm.group(1).strip()
+                    ftype = fm.group(2).strip()
+                    default = fm.group(4).strip() if fm.group(4) else None
+                    fields.append(f"{fname}:{ftype}" + (f"={default}" if default else ""))
+                k += 1
+
+            out.append((name, fields))
+            i = k
+        else:
+            i += 1
+
+    return out
+
+
+# ----------------- printing -----------------
+def _print_section(title: str) -> None:
+    typer.echo("")
+    typer.echo(title)
+    typer.echo("-" * len(title))
+
+
+def _fmt_item(name: str, fields: list[str], show_path: bool, rel: str) -> str:
+    f = ", ".join(fields) if fields else "(no fields found)"
+    return f"• {name}: {f}" + (f"  ({rel})" if show_path else "")
+
+
+def register_types_command(app: typer.Typer) -> None:
+    @app.command("types")
+    def types_cmd(
+        path: str = typer.Argument(".", help="Project root/folder to scan"),
+        contains: str = typer.Option("", "-c", "--contains", help="Filter by path substring"),
+        max_files: int = typer.Option(500, "-n", "--max-files", help="Max files per language"),
+        max_kb: int = typer.Option(256, "--max-kb", help="Max KB to read per file"),
+        show_path: bool = typer.Option(False, "--show-path", help="Show source file path"),
+    ) -> None:
+        root = Path(path).resolve()
+        if not root.exists():
+            raise typer.BadParameter(f"Path not found: {root}")
+
+        filt = contains.strip().lower()
+
+        java_files: list[Path] = []
+        py_files: list[Path] = []
+
+        for f in _walk_files(root):
+            rel = _rel(f, root)
+            if filt and filt not in rel.lower():
+                continue
+            if _is_java_dto(f):
+                java_files.append(f)
+            elif _is_python_dto_like(f):
+                py_files.append(f)
+
+        java_files.sort(key=lambda p: _rel(p, root).lower())
+        py_files.sort(key=lambda p: _rel(p, root).lower())
+
+        typer.echo(f"ROOT: {root}")
+        typer.echo(f"Filter: {contains!r}" if contains else "Filter: (none)")
+
+        # ---- JAVA ----
+        java_items: list[dict[str, Any]] = []
+        for f in java_files[:max_files]:
+            src = _read_text_limited(f, max_kb=max_kb)
+            rel = _rel(f, root)
+
+            parsed = _parse_java_record(src)
+            if parsed:
+                name, fields = parsed
+                kind = _classify_java(rel, name)
+                java_items.append({"kind": kind, "name": name, "fields": fields, "path": rel})
+                continue
+
+            parsed2 = _parse_java_class_fields(src)
+            if parsed2:
+                name, fields = parsed2
+                kind = _classify_java(rel, name)
+                java_items.append({"kind": kind, "name": name, "fields": fields, "path": rel})
+
+        # ---- PYTHON ----
+        py_items: list[dict[str, Any]] = []
+        for f in py_files[:max_files]:
+            rel = _rel(f, root)
+            if rel.endswith("__init__.py"):
+                continue
+            src = _read_text_limited(f, max_kb=max_kb)
+            for name, fields in _parse_python_dataclasses(src):
+                py_items.append({"name": name, "fields": fields, "path": rel})
+
+        # Print only the sections that exist (clean UX)
+        if java_items:
+            req = [x for x in java_items if x["kind"] == "request"]
+            res = [x for x in java_items if x["kind"] == "response"]
+            other = [x for x in java_items if x["kind"] == "other"]
+
+            _print_section(f"JAVA DTO SUMMARY ({len(java_items)})")
+
+            if req:
+                _print_section(f"WHAT WE SEND (REQUEST) ({len(req)})")
+                for x in req:
+                    typer.echo(_fmt_item(x["name"], x["fields"], show_path, x["path"]))
+
+            if res:
+                _print_section(f"WHAT WE RECEIVE (RESPONSE) ({len(res)})")
+                for x in res:
+                    typer.echo(_fmt_item(x["name"], x["fields"], show_path, x["path"]))
+
+            if other:
+                _print_section(f"OTHER JAVA DTO ({len(other)})")
+                for x in other:
+                    typer.echo(_fmt_item(x["name"], x["fields"], show_path, x["path"]))
+
+        if py_items:
+            _print_section(f"PYTHON DTO/MODEL SUMMARY ({len(py_items)})")
+            for x in py_items:
+                typer.echo(_fmt_item(x["name"], x["fields"], show_path, x["path"]))
+
+        if not java_items and not py_items:
+            typer.echo("")
+            typer.echo("(no DTO-like types found)")

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

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