boomtick-cli 0.2.1__py3-none-any.whl

dev_tools/pr_overlap.py

@@ -0,0 +1,139 @@
+# pylint: disable=invalid-name,line-too-long,missing-docstring,no-value-for-parameter
+import sys
+from collections import defaultdict
+from typing import Any, Dict, List
+
+import click
+from dev_tools.services.github import GitHubClient
+from dev_tools.utils import log_error, log_info
+
+
+def get_pr_overlaps(github: GitHubClient, limit: int) -> List[Dict[str, Any]]:
+    """
+    Identifies structural overlaps between open Pull Requests by analyzing modified file sets.
+
+    This function fetches open PRs from the repository, retrieves the list of modified files
+    for each PR, and identifies groups (clusters) of PRs that share at least one common file.
+    These clusters are useful for identifying potential merge conflicts or functional
+    dependencies that might necessitate PR consolidation.
+
+    Args:
+        github: An instance of GitHubClient to interact with the GitHub API.
+        limit: The maximum number of open PRs to retrieve for analysis.
+
+    Returns:
+        A list of cluster dictionaries, each containing:
+            - 'prs': A list of PR numbers in the cluster.
+            - 'files': A list of filenames shared across the PRs in the cluster.
+            - 'metadata': A dictionary mapping PR numbers to their full PR details.
+    """
+    # 1. Fetch open PRs
+    log_info(f"Fetching up to {limit} open PRs...")
+    prs = github.list_pull_requests(state="open", limit=limit)
+
+    if not prs:
+        log_info("No open PRs found.")
+        return []
+
+    # 2. Map files to PRs
+    file_to_prs = defaultdict(set)
+    pr_metadata = {}
+
+    for pr in prs:
+        pr_num = pr["number"]
+        pr_metadata[pr_num] = pr
+        log_info(f"Fetching files for PR #{pr_num}...")
+        try:
+            files = github.fetch_pr_files(pr_num)
+            for f in files:
+                filename = f.get("filename")
+                if filename:
+                    file_to_prs[filename].add(pr_num)
+        except Exception as e:
+            log_error(f"Failed to fetch files for PR #{pr_num}: {e}")
+
+    # 3. Identify clusters
+    # A cluster is a set of PRs that share at least one file.
+    # We use a simple disjoint-set or just group by overlap.
+    # For PR consolidation, we want to see pairs/groups that have overlaps.
+
+    overlaps = defaultdict(set)
+    for filename, pr_set in file_to_prs.items():
+        if len(pr_set) > 1:
+            sorted_prs = tuple(sorted(list(pr_set)))
+            overlaps[sorted_prs].add(filename)
+
+    clusters = []
+    for pr_set, files in overlaps.items():
+        clusters.append({
+            "prs": list(pr_set),
+            "files": sorted(list(files)),
+            "metadata": {num: pr_metadata[num] for num in pr_set}
+        })
+
+    # Sort clusters by number of overlapping files (descending)
+    clusters.sort(key=lambda x: len(x["files"]), reverse=True)
+    return clusters
+
+
+def report_overlaps(clusters: List[Dict[str, Any]]):
+    """
+    Generates and prints a Markdown-formatted report of identified PR overlaps to stdout.
+
+    The report includes details for each cluster, such as the involved PR numbers,
+    the author of each PR, and a list of the primary overlapping files. It also
+    provides actionable recommendations for consolidation or coordination.
+
+    Args:
+        clusters: A list of cluster dictionaries as returned by `get_pr_overlaps`.
+    """
+    if not clusters:
+        print("✅ No significant PR overlaps detected.")
+        return
+
+    print("# Active PR Overlap Analysis")
+    print("Identified clusters of PRs with shared file modifications.\n")
+
+    for i, cluster in enumerate(clusters, 1):
+        pr_list = cluster["prs"]
+        files = cluster["files"]
+        metadata = cluster["metadata"]
+
+        print(f"## Cluster {i}: PRs {', '.join(f'#{num}' for num in pr_list)}")
+        print(f"**Primary Overlap:** {len(files)} files")
+
+        # List top 10 files
+        for f in files[:10]:
+            print(f"- `{f}`")
+        if len(files) > 10:
+            print(f"- ... and {len(files) - 10} more")
+
+        print("\n**Involved PRs:**")
+        for num in pr_list:
+            pr = metadata[num]
+            print(f"- **#{num}**: {pr.get('title')} (Author: @{pr.get('author', {}).get('login', 'unknown')})")
+
+        print("\n**Recommendation:** Merge/Coordinate")
+        print("**Rationale:** High file overlap suggests these PRs may have functional dependencies or cause merge conflicts.")
+        print("\n---\n")
+
+
+@click.command()
+@click.option("--limit", default=20, help="Limit the number of PRs to process")
+@click.option("--no-cache", is_flag=True, help="Bypass the disk cache for GitHub API calls")
+def run_cli(limit, no_cache):
+    try:
+        github = GitHubClient(no_cache=no_cache)
+        clusters = get_pr_overlaps(github, limit)
+        report_overlaps(clusters)
+    except Exception as e:
+        log_error(f"Overlap analysis failed: {e}")
+        sys.exit(1)
+
+
+def main():
+    run_cli()  # pylint: disable=no-value-for-parameter
+
+
+if __name__ == "__main__":
+    main()

dev_tools/resources/__init__.py

@@ -0,0 +1 @@
+# pylint: disable=missing-docstring

dev_tools/resources/build-repo-context.py

@@ -0,0 +1,182 @@
+# pylint: disable=import-outside-toplevel,invalid-name,line-too-long,missing-docstring,too-many-branches,too-many-locals,too-many-statements
+#!/usr/bin/env python3
+import json
+import pathlib
+import sys
+
+
+def build_repo_context():
+    """Gathers static context about the repository."""
+
+    # Discovery: find the repo root and package root
+    script_path = pathlib.Path(__file__).resolve()
+    # boomtick-pkg/scripts/build-repo-context.py -> boomtick-pkg
+    package_root = script_path.parent.parent
+
+    # Check if we are in a monorepo or a standalone repo
+    if (package_root.parent / "package.json").exists() and (package_root.parent / "boomtick-pkg").exists():
+        # Monorepo mode
+        repo_root = package_root.parent
+    else:
+        # Standalone mode
+        repo_root = package_root
+
+    # If we are running from a location that isn't boomtick-pkg/scripts,
+    # fallback to discovery based on workspace.json
+    if package_root.name != "boomtick-pkg" or not (package_root / "workspace.json").exists():
+        # Search upwards for workspace.json using Path.parents
+        found_pkg = False
+        for parent in script_path.parents:
+            if (parent / "workspace.json").exists():
+                package_root = parent
+                found_pkg = True
+                break
+
+        if found_pkg:
+            if (package_root.parent / "package.json").exists() and (package_root.parent / "boomtick-pkg").exists():
+                repo_root = package_root.parent
+            else:
+                repo_root = package_root
+        else:
+            # Absolute fallback
+            repo_root = pathlib.Path(".").resolve()
+            package_root = repo_root if (repo_root / "workspace.json").exists() else repo_root / "boomtick-pkg"
+
+    # 1. Package JSON (Repo Root)
+    try:
+        package_json_path = repo_root / "package.json"
+        if not package_json_path.exists() and (repo_root / "workspace.json").exists():
+            # In extracted standalone mode, use workspace.json as the package authority
+            package_json_path = repo_root / "workspace.json"
+
+        package_json = json.loads(package_json_path.read_text())
+        # simplify package.json to the most important parts for context
+        package_summary = {
+            "name": package_json.get("name"),
+            "scripts": package_json.get("scripts", {}),
+            "dependencies": sorted(list(package_json.get("dependencies", {}).keys())),
+            "devDependencies": sorted(list(package_json.get("devDependencies", {}).keys())),
+        }
+    except Exception as e:
+        print(f"Error reading package.json: {e}", file=sys.stderr)
+        package_summary = {}
+
+    # 2. Project Config (Repo Root)
+    project_config = {}
+    try:
+        project_config_path = repo_root / "project_config.json"
+        if project_config_path.exists():
+            project_config = json.loads(project_config_path.read_text())
+    except Exception as e:
+        print(f"Error reading project_config.json: {e}", file=sys.stderr)
+
+    # 3. MCP Schema (Package Internal)
+    mcp_schema = {"tools": [], "prompts": [], "resources": []}
+    try:
+        import subprocess
+
+        mcp_dir = package_root / "mcp"
+        if mcp_dir.exists():
+            # Use npx tsx to run the export script without needing to compile it
+            # We run it from the mcp_dir to ensure it finds its own local config
+            result = subprocess.run(
+                ["npx", "tsx", "scripts/export-mcp-schema.ts"],
+                cwd=str(mcp_dir),
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            mcp_schema = json.loads(result.stdout)
+    except Exception as e:
+        print(f"Error gathering MCP schema: {e}", file=sys.stderr)
+
+    # 4. CLI Schema (Package Internal)
+    cli_schema = {
+        "tool_name": "td-cli",
+        "schema_authority": "Use 'repo.get_command_schema' or 'td-cli schema <path>' for granular discovery. This file remains for legacy fallback.",
+        "description": "Custom developer CLI for BoomTick repository management.",
+        "base_command": "td-cli",
+    }
+    try:
+        from dev_tools.cli import cli
+        from dev_tools.schema_utils import collect_commands
+
+        # We keep cli-schema.json updated but minimal for the aggregate context
+        # Increasing max_depth to 2 to allow discovery of nested subcommands (e.g., gh search-prs)
+        generated_subcommands = collect_commands(cli, max_depth=2)
+        cli_schema["subcommands"] = generated_subcommands
+
+        cli_schema_path = package_root / "cli" / "dev_tools" / "cli-schema.json"
+
+        # Write full schema for legacy/reference but don't bloat the agent context
+        full_subcommands = collect_commands(cli)
+        full_payload = cli_schema.copy()
+        full_payload["subcommands"] = full_subcommands
+        cli_schema_path.write_text(json.dumps(full_payload, indent=2))
+
+        # Also trigger Pydantic model contract generation
+        try:
+            import io
+            from contextlib import redirect_stdout
+
+            from dev_tools.schema_gen import generate_schema
+
+            # Capture stdout to ensure clean JSON output for build-repo-context.py
+            with redirect_stdout(io.StringIO()):
+                generate_schema()
+            # Note: sync-contracts.ts is run via pnpm run verify:schemas or manually
+        except Exception as schema_err:
+            print(f"Error generating model schemas: {schema_err}", file=sys.stderr)
+
+    except Exception as e:
+        print(f"Error generating cli-schema.json dynamically: {e}", file=sys.stderr)
+        # Fallback to reading file if generation failed
+        try:
+            cli_schema_path = package_root / "cli" / "dev_tools" / "cli-schema.json"
+            if cli_schema_path.exists():
+                cli_schema = json.loads(cli_schema_path.read_text())
+        except Exception as read_err:
+            print(f"Fallback read of cli-schema.json failed: {read_err}", file=sys.stderr)
+
+    # 5. File Tree (Repo Root)
+    def get_dir_structure(path, max_depth=2, current_depth=0):
+        if current_depth >= max_depth:
+            return "..."
+        structure = {}
+        try:
+            for item in sorted(path.iterdir()):
+                if item.name.startswith(".") or item.name == "node_modules" or item.name == "__pycache__":
+                    continue
+                if item.is_dir():
+                    structure[item.name + "/"] = get_dir_structure(item, max_depth, current_depth + 1)
+                else:
+                    structure[item.name] = None
+        except Exception:
+            pass
+        return structure
+
+    file_tree = get_dir_structure(repo_root)
+
+    # Assemble context
+    return {
+        "repo": {
+            "name": package_summary.get("name", "Unknown Repo"),
+        },
+        "package_json": package_summary,
+        "project_config": project_config,
+        "mcp_schema": mcp_schema,
+        "cli_schema": cli_schema,
+        "file_tree": file_tree,
+    }
+
+
+if __name__ == "__main__":
+    try:
+        context = build_repo_context()
+        if not context.get("package_json"):
+            raise ValueError("Failed to gather basic repository context (package.json missing or invalid)")
+        # sort_keys=True ensures the output is deterministic for revision control
+        print(json.dumps(context, indent=2, sort_keys=True))
+    except Exception as e:
+        print(f"FATAL: Context generation failed: {e}", file=sys.stderr)
+        sys.exit(1)

dev_tools/resources/prompt_constants.json

@@ -0,0 +1,5 @@
+{
+  "STRICT_JSON_VERIFICATION": "Strict JSON Verification:\n- You MUST self-verify the completeness and validity of the JSON block before finishing your response.\n- Every finding MUST have an `id`, `file`, `issue`, and `status`.\n- Ensure the JSON is well-formed and contained entirely within the `<findings>` tags.\n- Ensure 'snippet' is a unique string from the diff that identifies the issue.",
+  "SNIPPET_AND_VERIFICATION_RULES": "Snippet and verification rules:\n- STRICT SNIPPET RULE: When citing an error or anti-pattern, you MUST quote the entire, exact line from the diff in the \"snippet\" field. Do not truncate the line.\n- Before flagging a \"syntax error\" or \"missing property/method\", re-read the diff to confirm the code isn't simply continued on the next line or truncated in the diff chunk. Hallucinating errors due to chunk truncation is a severe failure.\n- If a line appears truncated in the diff (e.g. at the edge of a chunk), DO NOT assume it is a syntax error. Assume it is valid code that continues outside the visible context.",
+  "COMMON_REVIEW_GUIDELINES": "Review ONLY PR changes. Assume original code worked.\nEVIDENCE RULE: Issue must point to exact line + explain runtime consequence.\nFALSE POSITIVE FILTER: No speculation. Design choices are NOT bugs.\n\nTIERED SCOPE:\n- For App/UI (src/): Flag redundant wrappers. BANNED: Raw Tailwind layout (flex/grid/px-*) in TSX (use Stack/Grid/Box).\n- For Infra/Tooling (scripts/, boomtick-pkg/cli/, .github/): Focus on portability, idempotency, and error handling. Avoid UI-specific feedback for low-level scripts.\n\nREPO RULES: Prefer removal.\nANTI-SLOP: DO NOT recommend overly complex error handling, defensive guards, extra unit tests for simple internal scripts, or boilerplate documentation/comments.\n\n- FILE NECESSITY: Question any added, moved, or removed files that look like temporary artifacts (e.g. .tmp, standalone .py in root, audit-*.md, .json dumps) or seem unrelated to the PR intent. Flag them for removal if they pollute the review context."
+}

dev_tools/resources/review_template.md

@@ -0,0 +1,41 @@
+# PR Review: #{pr_num}
+
+## Context
+
+- **Last Commit Tracked (SHA):** {head_sha}
+
+## Audit Checklist
+
+For EVERY changed file, verify against these standards. Mark as `- [x]` when verified.
+
+- [ ] Dead abstractions: No new class, context, or hook that a simpler primitive handles.
+- [ ] Unnecessary indirection: No layer of wrapping where a direct function call suffices.
+- [ ] Responsibility creep: Component does not take on state/logic belonging in parent/hook.
+- [ ] Import bloat: No unnecessary `import React from 'react'` (React 17+).
+- [ ] Token compliance: Uses established design tokens (no raw Tailwind values or inline styles).
+- [ ] Audit ratio: If > 100 lines added, identified at least 10 lines to refactor/remove.
+
+## CI Log Triage
+
+(Populated if CI failures detected)
+- **Failed Checks:**
+{failed_checks}
+- **Detected Errors:**
+{detected_errors}
+- **Root Cause Analysis:**
+- **Remediation Steps:**
+
+## Output JSON
+
+Provide your findings and inline comments in the JSON block below.
+DO NOT REMOVE THE BACKTICKS.
+
+```json
+{{
+  "recommendation": "Approved",
+  "body": "## ANTI-AI-SLOP\\n<findings>\\n\\n## FINDINGS\\n<summary>\\n\\n## FINAL RECOMMENDATION\\n<Approved | Approved with Minor Changes | Not Approved>\\n\\n<!-- td-review-manager-comment -->",
+  "recommendation": "<Approved | Approved with Minor Changes | Not Approved>",
+  "labels": [],
+  "comments": []
+}}
+```

dev_tools/resources/ux-audit.config.json

@@ -0,0 +1,15 @@
+{
+  "baseUrl": "http://localhost:3000",
+  "viewports": {
+    "desktop": [
+      { "name": "desktop-1280", "width": 1280, "height": 800 },
+      { "name": "desktop-1440", "width": 1440, "height": 900 }
+    ],
+    "mobile": [
+      { "name": "mobile-375", "width": 375, "height": 812 },
+      { "name": "mobile-390", "width": 390, "height": 844 },
+      { "name": "mobile-430", "width": 430, "height": 932 }
+    ]
+  },
+  "outputDir": "artifacts/ux-audit"
+}

dev_tools/resources/visual_guidelines.json

@@ -0,0 +1,3 @@
+{
+  "VISUAL_DESIGN_GUIDELINES": "### VISUAL & DESIGN GUIDELINES (Impeccable System)\nReviewing agents must audit pull requests against the following visual constraints:\n\nA. Color & Contrast Rules\n- WCAG Contrast: Body text against background must be >= 4.5:1. Large text (>= 18px or bold >= 14px) must be >= 3:1.\n- Theme Anchor: Midnight Luster (#020617 / oklch(10% 0.02 240)) base canvas, with luminous Cyber Cyan (#22d3ee / oklch(75% 0.18 190)) triggers. No saturated cream, sand, or paper backgrounds.\n- Color Strategy: Committed/Drenched accenting (color must feel intentional and carry the section, restricted to <= 10% on primary action areas).\n\nB. Typography Limits\n- Line Length: Max body width is 65–75ch to prevent scanning fatigue.\n- Display Headings: Letter-spacing floor >= -0.04em (prevent touching letters). Ceiling size max <= 6rem.\n- Line Balance: H1–H3 must use text-wrap: balance. Articles/prose must use text-wrap: pretty.\n\nC. Layout & Structure\n- No Card Nesting: Cards inside cards are prohibited.\n- Primitives: Flexbox/grid layouts must use standard abstractions (Stack, Grid, Box). Raw Tailwind layout rules (flex, grid, px-4) are banned in app layers.\n- Z-Index Scale: Semantic scale only (dropdown -> sticky -> modal -> toast). No magic numbers like z-[99999].\n\nD. Motion\n- Layout Animations: Do not animate CSS layout dimensions (width, height, flex) unless necessary (performance bottleneck).\n- Reduced Motion: Every transition must respect @media (prefers-reduced-motion: reduce).\n- Entrance reveals: Must degrade gracefully; never gate essential content visibility behind script-triggered animations.\n\nE. Absolute Bans (Auto-Reject Checklist)\n- Side-Stripe Borders: Banned border-left accents on list items/cards.\n- Gradient Text: Combinations of background-clip: text and gradients are banned.\n- Over-rounded Elements: Radius limit is 12–16px (no 32px+ pill cards).\n- Sketchy SVGs: Hand-drawn, sketchy, or crude illustrations are prohibited.\n- Tracked Kickers: Repeating Kickers/Eyebrows above every section is banned."
+}

dev_tools/review_read_pass.py

@@ -0,0 +1,232 @@
+# pylint: disable=import-outside-toplevel,missing-docstring,redefined-outer-name,too-many-locals
+#!/usr/bin/env python3
+"""
+review_read_pass.py – Diff parser and file-chunk splitter for the piecemeal
+AI review pipeline.
+
+Key exports
+-----------
+parse_diff_into_file_chunks(diff_text) -> list[dict]
+    Groups a unified diff into one chunk per file (or multiple chunks for
+    large files) and applies skip rules so non-code assets are never sent
+    to the AI reviewer.
+
+"""
+
+import json
+import re
+import sys
+from typing import Optional
+
+# ── Skip rules ────────────────────────────────────────────────────────────────
+# Files matching any of these patterns will be classified as skip=True.
+_SKIP_EXTENSIONS = {
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".ico",
+    ".webp",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".otf",  # images / fonts
+    ".mp4",
+    ".mov",
+    ".avi",
+    ".webm",  # video
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".br",  # binary archives
+    ".map",  # source maps
+}
+
+_SKIP_FILENAMES = {
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "composer.lock",
+    "Gemfile.lock",
+    "poetry.lock",  # lock files
+}
+
+_SKIP_PATTERNS = [
+    re.compile(r"\.min\.(js|css|mjs)$"),  # minified
+    re.compile(r"\.snap$"),  # Jest snapshots
+    re.compile(r"^(dist|build|\.next|out|\.nuxt)/"),  # build artifacts
+    re.compile(r"^__generated__/"),  # GraphQL / codegen
+]
+
+# Maximum diff characters sent per AI call for a single hunk-group
+MAX_CHUNK_CHARS = 8_000
+# Maximum added lines before we split a file's diff into multiple chunks
+HUNK_GROUP_SIZE = 50
+
+
+def _should_skip(filepath: str) -> Optional[str]:
+    """Return a human-readable skip reason, or None if the file should be reviewed."""
+    import os
+
+    basename = os.path.basename(filepath)
+    ext = os.path.splitext(basename)[1].lower()
+
+    if ext in _SKIP_EXTENSIONS:
+        return f"binary/image ({ext})"
+    if basename in _SKIP_FILENAMES:
+        return "lock file"
+    for pat in _SKIP_PATTERNS:
+        if pat.search(filepath):
+            return f"matches skip pattern ({pat.pattern})"
+    return None
+
+
+# ── Core diff parser ──────────────────────────────────────────────────────────
+
+
+def _parse_raw_files(diff_text: str) -> list[dict]:
+    """
+    Split a unified diff into a list of per-file raw dicts:
+      {file, hunks: [{header, lines, added_count}]}
+    """
+    files = []
+    current_file: Optional[str] = None
+    current_hunks: list = []
+    current_hunk: Optional[dict] = None
+
+    for line in diff_text.splitlines(keepends=True):
+        if line.startswith("diff --git"):
+            if current_file is not None:
+                if current_hunk:
+                    current_hunks.append(current_hunk)
+                files.append({"file": current_file, "hunks": current_hunks})
+            current_file = None
+            current_hunks = []
+            current_hunk = None
+        elif line.startswith("+++ b/"):
+            current_file = line[6:].rstrip("\n")
+        elif line.startswith("@@ "):
+            if current_hunk:
+                current_hunks.append(current_hunk)
+            current_hunk = {"header": line, "lines": [], "added_count": 0}
+        elif current_hunk is not None:
+            current_hunk["lines"].append(line)
+            if line.startswith("+") and not line.startswith("+++"):
+                current_hunk["added_count"] += 1
+
+    # flush last file
+    if current_file is not None:
+        if current_hunk:
+            current_hunks.append(current_hunk)
+        files.append({"file": current_file, "hunks": current_hunks})
+
+    return files
+
+
+def _hunk_to_text(hunk: dict) -> str:
+    return hunk["header"] + "".join(hunk["lines"])
+
+
+def parse_diff_into_file_chunks(diff_text: str) -> list[dict]:
+    """
+    Main entry point for the piecemeal review pipeline.
+
+    Returns a list of chunk dicts:
+    {
+        "file": str,          # relative path
+        "chunk_index": int,   # 0-based (most files have only one chunk)
+        "total_chunks": int,
+        "skip": bool,
+        "reason": str | None, # populated when skip=True
+        "diff_text": str,     # the raw diff text for this chunk
+        "added_lines": int,
+        "truncated": bool,    # True when diff_text was trimmed to MAX_CHUNK_CHARS
+    }
+    """
+    raw_files = _parse_raw_files(diff_text)
+    chunks = []
+
+    for rf in raw_files:
+        filepath = rf["file"]
+        hunks = rf["hunks"]
+
+        skip_reason = _should_skip(filepath)
+
+        if skip_reason or not hunks:
+            chunks.append(
+                {
+                    "file": filepath,
+                    "chunk_index": 0,
+                    "total_chunks": 1,
+                    "skip": True,
+                    "reason": skip_reason or "no hunks",
+                    "diff_text": "",
+                    "added_lines": 0,
+                    "truncated": False,
+                }
+            )
+            continue
+
+        # Group hunks into batches of ≤ HUNK_GROUP_SIZE added lines each
+        groups: list[list[dict]] = []
+        current_group: list[dict] = []
+        current_added = 0
+
+        for hunk in hunks:
+            if current_added + hunk["added_count"] > HUNK_GROUP_SIZE and current_group:
+                groups.append(current_group)
+                current_group = []
+                current_added = 0
+            current_group.append(hunk)
+            current_added += hunk["added_count"]
+
+        if current_group:
+            groups.append(current_group)
+
+        total_chunks = len(groups)
+
+        for idx, group in enumerate(groups):
+            text = f"--- a/{filepath}\n+++ b/{filepath}\n"
+            text += "".join(_hunk_to_text(h) for h in group)
+            added = sum(h["added_count"] for h in group)
+            truncated = False
+
+            if len(text) > MAX_CHUNK_CHARS:
+                text = text[:MAX_CHUNK_CHARS] + f"\n... (diff truncated at {MAX_CHUNK_CHARS} chars)"
+                truncated = True
+
+            chunks.append(
+                {
+                    "file": filepath,
+                    "chunk_index": idx,
+                    "total_chunks": total_chunks,
+                    "skip": False,
+                    "reason": None,
+                    "diff_text": text,
+                    "added_lines": added,
+                    "truncated": truncated,
+                }
+            )
+
+    return chunks
+
+
+if __name__ == "__main__":
+    raw = sys.stdin.read()
+    chunks = parse_diff_into_file_chunks(raw)
+    reviewable = [c for c in chunks if not c["skip"]]
+    skipped = [c for c in chunks if c["skip"]]
+    print(
+        json.dumps(
+            {
+                "total_chunks": len(chunks),
+                "reviewable": len(reviewable),
+                "skipped": len(skipped),
+                "chunks": chunks,
+            },
+            indent=2,
+        )
+    )

dev_tools/schema_gen.py

@@ -0,0 +1,55 @@
+# pylint: disable=consider-using-from-import,import-outside-toplevel,missing-docstring
+import inspect
+import json
+import os
+
+import dev_tools.models as models
+from pydantic import BaseModel
+
+
+def get_models_schema():
+    schemas = {}
+    for name, obj in inspect.getmembers(models):
+        if inspect.isclass(obj) and issubclass(obj, BaseModel) and obj is not BaseModel:
+            # Skip base classes if any
+            if name in ("CLIResponse", "CLIInput"):
+                continue
+            # Force export using field names (camelCase) instead of aliases (snake_case)
+            schemas[name] = obj.model_json_schema(by_alias=False)
+    return schemas
+
+
+def generate_schema():
+    schemas = {
+        "_warning": "AUTO-GENERATED: DO NOT EDIT MANUALLY. Update models.py instead.",
+        "models": get_models_schema(),
+    }
+
+    # Use cli-schema.json as the unified target
+    output_path = os.path.join(os.path.dirname(__file__), "cli-schema.json")
+
+    # Read existing if exists to merge
+    existing = {}
+    if os.path.exists(output_path):
+        try:
+            with open(output_path, "r", encoding="utf-8") as f:
+                existing = json.load(f)
+        except Exception as e:
+            print(f"Warning: Could not read existing cli-schema.json: {e}")
+
+    existing.update(schemas)
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(existing, f, indent=2)
+        f.write("\n")
+
+    import sys
+
+    print(
+        f"Updated cli-schema.json with {len(schemas['models'])} models at {output_path}",
+        file=sys.stderr,
+    )
+
+
+if __name__ == "__main__":
+    generate_schema()