gwc-pybundle 1.4.5__py3-none-any.whl

pybundle/steps/radon.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for tool execution, paths validated
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+def _repo_has_py_files(root: Path) -> bool:
+    """Fast check if there are Python files to scan."""
+    for p in root.rglob("*.py"):
+        parts = set(p.parts)
+        if (
+            ".venv" not in parts
+            and "__pycache__" not in parts
+            and "node_modules" not in parts
+            and "dist" not in parts
+            and "build" not in parts
+            and "artifacts" not in parts
+        ):
+            return True
+    return False
+
+
+@dataclass
+class RadonStep:
+    name: str = "radon"
+    target: str = "."
+    outfile: str = "logs/51_radon_complexity.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        radon = which("radon")
+        if not radon:
+            out.write_text(
+                "radon not found; skipping (pip install radon)\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing radon")
+
+        if not _repo_has_py_files(ctx.root):
+            out.write_text("no .py files detected; skipping radon\n", encoding="utf-8")
+            return StepResult(self.name, "SKIP", 0, "no python files")
+
+        target_path = ctx.root / self.target
+        
+        # Run cyclomatic complexity check
+        cmd_cc = [
+            radon,
+            "cc",
+            str(target_path),
+            "-s",  # Show complexity score
+            "-a",  # Average complexity
+            "-nc", # No color
+        ]
+        
+        # Run maintainability index check
+        cmd_mi = [
+            radon,
+            "mi",
+            str(target_path),
+            "-s",  # Show maintainability index
+            "-nc", # No color
+        ]
+
+        try:
+            # Collect both metrics in one output file
+            with out.open("w", encoding="utf-8") as f:
+                f.write("=" * 70 + "\n")
+                f.write("CYCLOMATIC COMPLEXITY\n")
+                f.write("=" * 70 + "\n\n")
+                
+                result_cc = subprocess.run(  # nosec B603 - Using full path from which()
+                    cmd_cc,
+                    cwd=ctx.root,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    timeout=120,
+                )
+                f.write(result_cc.stdout)
+                
+                f.write("\n\n")
+                f.write("=" * 70 + "\n")
+                f.write("MAINTAINABILITY INDEX\n")
+                f.write("=" * 70 + "\n\n")
+                
+                result_mi = subprocess.run(  # nosec B603 - Using full path from which()
+                    cmd_mi,
+                    cwd=ctx.root,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    timeout=120,
+                )
+                f.write(result_mi.stdout)
+
+            elapsed = int((time.time() - start) * 1000)
+            
+            # Radon returns 0 on success
+            if result_cc.returncode == 0 and result_mi.returncode == 0:
+                return StepResult(self.name, "OK", elapsed, None)
+            else:
+                return StepResult(
+                    self.name, 
+                    "FAIL", 
+                    elapsed, 
+                    f"exit cc:{result_cc.returncode} mi:{result_mi.returncode}"
+                )
+        except subprocess.TimeoutExpired:
+            out.write_text("radon timed out after 120s\n", encoding="utf-8")
+            return StepResult(self.name, "FAIL", 120000, "timeout")
+        except Exception as e:
+            out.write_text(f"radon error: {e}\n", encoding="utf-8")
+            return StepResult(self.name, "FAIL", 0, str(e))

pybundle/steps/repro_md.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import platform
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+@dataclass
+class ReproMarkdownStep:
+    name: str = "generate REPRO.md"
+    outfile: str = "REPRO.md"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        repro = ctx.workdir / self.outfile
+
+        # ---- tool detection ----
+        tool_names = [
+            "python",
+            "pip",
+            "git",
+            "ruff",
+            "mypy",
+            "pytest",
+            "rg",
+            "zip",
+            "tar",
+        ]
+        detected = {t: which(t) for t in tool_names}
+
+        # Prefer ctx.tools.python if you have it
+        if getattr(ctx, "tools", None) and getattr(ctx.tools, "python", None):
+            detected["python"] = ctx.tools.python
+
+        # ---- file inventory (what actually exists) ----
+        def list_txt(dirpath: Path) -> list[str]:
+            if not dirpath.is_dir():
+                return []
+            return sorted(
+                str(p.relative_to(ctx.workdir)) for p in dirpath.rglob("*.txt")
+            )
+
+        logs_list = list_txt(ctx.logdir)
+        meta_list = list_txt(ctx.metadir)
+
+        # Also include key top-level files if present
+        top_files = []
+        for name in [
+            "RUN_LOG.txt",
+            "SUMMARY.json",
+            "error_files_from_logs.txt",
+            "error_refs_count.txt",
+        ]:
+            p = ctx.workdir / name
+            if p.exists():
+                top_files.append(name)
+
+        # ---- step summary (best-effort, never crash) ----
+        results = getattr(ctx, "results", [])
+        ctx.results = results  # ensure it's set for future steps
+
+        summary_lines = []
+        for r in results:
+            note = f" ({r.note})" if getattr(r, "note", "") else ""
+            summary_lines.append(f"- **{r.name}**: {r.status}{note}")
+
+        # ---- environment ----
+        pyver = sys.version.split()[0]
+        plat = platform.platform()
+        profile = ctx.profile_name
+        utc_now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+        # ---- build markdown ----
+        def fmt_tool(t: str) -> str:
+            path = detected.get(t)
+            return f"- `{t}`: ✅ `{path}`" if path else f"- `{t}`: ❌ not found"
+
+        md = []
+        md += ["# Reproduction Guide", ""]
+        md += [
+            "This bundle captures diagnostic outputs and the minimum relevant project context",
+            "to reproduce issues reliably on another system.",
+            "",
+            "## Overview",
+            f"- Profile: `{profile}`",
+            f"- Generated (UTC): `{utc_now}`",
+            f"- Project root: `{ctx.root}`",
+            "",
+            "## Environment Snapshot",
+            f"- OS: `{plat}`",
+            f"- Python: `{pyver}`",
+            "",
+            "## Tools Detected",
+            *[fmt_tool(t) for t in tool_names],
+            "",
+        ]
+
+        if summary_lines:
+            md += ["## Steps Executed", *summary_lines, ""]
+
+        md += [
+            "## How to Reproduce",
+            "",
+            "From the project root:",
+            "",
+            "```bash",
+            f"python -m pybundle run {profile}",
+            "```",
+            "",
+            "Re-run individual tools (if installed):",
+            "",
+            "```bash",
+            "python -m compileall .",
+            "ruff check .",
+            "ruff format --check .",
+            "mypy .",
+            "pytest -q",
+            "```",
+            "",
+            "## Produced Artifacts",
+            "",
+        ]
+
+        if top_files:
+            md += ["### Top-level", *[f"- `{p}`" for p in top_files], ""]
+
+        md += (
+            ["### logs/", *(f"- `{p}`" for p in logs_list)]
+            if logs_list
+            else ["### logs/", "- (none)", ""]
+        )
+        md += (
+            ["", "### meta/", *(f"- `{p}`" for p in meta_list)]
+            if meta_list
+            else ["", "### meta/", "- (none)"]
+        )
+
+        md += [
+            "",
+            "## Context Packs",
+            "",
+            "- `src/_error_refs/` – files directly referenced by tool output",
+            "- `src/_error_context/` – related imports + pytest glue (conftest/__init__) + configs",
+            "",
+            "## Notes",
+            "",
+            "- Non-zero exits from linters/tests are recorded for diagnosis; bundle creation continues.",
+            "- Missing tools typically produce SKIP logs rather than failing the bundle.",
+            "",
+        ]
+
+        repro.write_text("\n".join(md) + "\n", encoding="utf-8")
+
+        dur = int(time.time() - start)
+        return StepResult(self.name, "PASS", dur, "")

pybundle/steps/rg_scans.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for tool execution, paths validated
+import time
+from dataclasses import dataclass
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+@dataclass
+class RipgrepScanStep:
+    name: str
+    pattern: str
+    outfile: str
+    target: str = "."  # directory or file
+    extra_args: list[str] | None = None
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        rg = which("rg")
+        if not rg:
+            out.write_text(
+                "rg (ripgrep) not found; skipping (install ripgrep)\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing rg")
+
+        args = self.extra_args or []
+        # -n line numbers, --no-heading keeps it grep-like, -S smart case can be handy
+        cmd = [rg, "-n", "--no-heading", "-S", *args, self.pattern, self.target]
+        header = f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n\n"
+
+        cp = subprocess.run(  # nosec B603
+            cmd, cwd=str(ctx.root), text=True, capture_output=True, check=False
+        )
+        # rg exit codes:
+        # 0 = matches found
+        # 1 = no matches found (not an error!)
+        # 2 = actual error
+        text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+        out.write_text(ctx.redact_text(text), encoding="utf-8")
+
+        dur = int(time.time() - start)
+        note = ""
+        if cp.returncode == 2:
+            note = "rg error (exit=2) recorded"
+        elif cp.returncode == 1:
+            note = "no matches"
+
+        # Always PASS; we’re collecting info, not enforcing policy (yet).
+        return StepResult(self.name, "PASS", dur, note)
+
+
+def default_rg_steps(target: str = ".") -> list[RipgrepScanStep]:
+    return [
+        RipgrepScanStep(
+            name="rg TODO/FIXME/HACK",
+            pattern=r"TODO|FIXME|HACK",
+            outfile="logs/40_rg_todos.txt",
+            target=target,
+        ),
+        RipgrepScanStep(
+            name="rg print(",
+            pattern=r"^\s*print\(",
+            outfile="logs/41_rg_prints.txt",
+            target=target,
+        ),
+        RipgrepScanStep(
+            name="rg except patterns",
+            pattern=r"except\s+Exception|except\s*:",
+            outfile="logs/42_rg_bare_excepts.txt",
+            target=target,
+        ),
+    ]

pybundle/steps/roadmap.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+from .base import StepResult
+from ..context import BundleContext
+from ..policy import AIContextPolicy
+from ..roadmap_scan import build_roadmap  # keep only if you actually use it
+
+
+class RoadmapGraph(Protocol):
+    entrypoints: list[Any]
+    nodes: list[Any]
+    edges: list[Any]
+    stats: dict[str, Any]
+
+
+@dataclass
+class RoadmapStep:
+    name: str = "roadmap (project map)"
+    out_md: str = "meta/70_roadmap.md"
+    out_json: str = "meta/70_roadmap.json"
+    include: list[str] | None = None
+    policy: AIContextPolicy | None = None
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+
+        policy = self.policy or AIContextPolicy()
+
+        # Include dirs: explicit override wins; otherwise policy candidates (with fallback)
+        if self.include:
+            include_dirs = [
+                ctx.root / p for p in self.include if (ctx.root / p).exists()
+            ]
+            if not include_dirs:
+                include_dirs = [ctx.root]
+        else:
+            include_dirs = policy.include_dir_candidates(
+                ctx.root
+            )  # includes fallback to [root]
+
+        exclude_dirs = set(policy.exclude_dirs)
+
+        graph = build_roadmap(
+            root=ctx.root,
+            include_dirs=include_dirs,
+            exclude_dirs=exclude_dirs,
+            max_files=policy.roadmap_max_files,
+        )
+
+        # JSON
+        out_json_path = ctx.workdir / self.out_json
+        out_json_path.parent.mkdir(parents=True, exist_ok=True)
+        out_json_path.write_text(
+            json.dumps(graph.to_dict(), indent=2), encoding="utf-8"
+        )
+
+        # Markdown (policy-driven Mermaid knobs)
+        out_md_path = ctx.workdir / self.out_md
+        out_md_path.parent.mkdir(parents=True, exist_ok=True)
+        out_md_path.write_text(self._render_md(graph, policy), encoding="utf-8")
+
+        langs = sorted({n.lang for n in graph.nodes if getattr(n, "lang", None)})
+        summary = {
+            "languages": langs,
+            "entrypoints": [ep.node for ep in graph.entrypoints[:50]],
+            "stats": graph.stats,
+        }
+        (ctx.workdir / "meta" / "71_roadmap_summary.json").write_text(
+            json.dumps(summary, indent=2), encoding="utf-8"
+        )
+
+        dur = int(time.time() - start)
+        note = f"nodes={len(graph.nodes)} edges={len(graph.edges)} entrypoints={len(graph.entrypoints)}"
+        return StepResult(self.name, "PASS", dur, note)
+
+    def _render_md(self, graph: RoadmapGraph, policy: AIContextPolicy) -> str:
+        depth = policy.roadmap_mermaid_depth
+        max_edges = policy.roadmap_mermaid_max_edges
+
+        lines: list[str] = []
+        lines.append("# Project Roadmap")
+        lines.append("")
+        lines.append("## Entrypoints")
+        if not graph.entrypoints:
+            lines.append("- (none detected)")
+        else:
+            for ep in graph.entrypoints[:50]:
+                lines.append(
+                    f"- `{ep.node}` — {ep.reason} (confidence {ep.confidence}/3)"
+                )
+        lines.append("")
+        lines.append("## High-level map")
+        lines.append("```mermaid")
+        lines.append("flowchart LR")
+        lines.extend(
+            self._render_mermaid_bfs(graph, max_depth=depth, max_edges=max_edges)
+        )
+        lines.append("```")
+        lines.append("")
+        lines.append("## Stats")
+        for k in sorted(graph.stats.keys()):
+            lines.append(f"- **{k}**: {graph.stats[k]}")
+        lines.append("")
+        lines.append("## Notes")
+        lines.append(
+            "- Destinations like `py:...`, `js:...`, `rs:...` are dependency specs (not resolved to paths yet)."
+        )
+        lines.append(
+            "- This is designed to be deterministic and readable, not a perfect compiler-grade call graph."
+        )
+        lines.append("")
+        return "\n".join(lines)
+
+    def _render_mermaid_bfs(
+        self, graph: RoadmapGraph, max_depth: int = 2, max_edges: int = 180
+    ) -> list[str]:
+        from collections import deque
+
+        adj: dict[str, list[str]] = {}
+        for e in graph.edges:
+            adj.setdefault(e.src, []).append(e.dst)
+
+        entry = [ep.node for ep in graph.entrypoints]
+        if not entry:
+            return ['  A["(no entrypoints)"]']
+
+        q = deque([(n, 0) for n in entry])
+        seen_edges: set[tuple[str, str]] = set()
+        shown: list[str] = []
+        seen_nodes: set[str] = set(entry)
+
+        while q and len(shown) < max_edges:
+            node, depth = q.popleft()
+            if depth >= max_depth:
+                continue
+            for dst in adj.get(node, []):
+                key = (node, dst)
+                if key in seen_edges:
+                    continue
+                seen_edges.add(key)
+                shown.append(f'  "{node}" --> "{dst}"')
+                if dst not in seen_nodes:
+                    seen_nodes.add(dst)
+                    q.append((dst, depth + 1))
+                if len(shown) >= max_edges:
+                    break
+
+        return shown or ['  A["(no edges rendered)"]']

pybundle/steps/ruff.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for tool execution, paths validated
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+def _repo_has_py_files(root: Path) -> bool:
+    # Fast-ish heuristic: look for any .py file in top couple levels
+    # (Avoid walking deep trees; ruff itself can handle it.)
+    for p in root.rglob("*.py"):
+        # ignore common junk dirs
+        parts = set(p.parts)
+        if (
+            ".venv" in parts
+            or "__pycache__" in parts
+            or ".mypy_cache" in parts
+            or ".ruff_cache" in parts
+        ):
+            continue
+        if (
+            "node_modules" in parts
+            or "dist" in parts
+            or "build" in parts
+            or "artifacts" in parts
+        ):
+            continue
+        return True
+    return False
+
+
+@dataclass
+class RuffCheckStep:
+    name: str = "ruff check"
+    target: str = "."
+    outfile: str = "logs/31_ruff_check.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        ruff = which("ruff")
+        if not ruff:
+            out.write_text(
+                "ruff not found; skipping (pip install ruff)\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing ruff")
+
+        if not _repo_has_py_files(ctx.root):
+            out.write_text(
+                "no .py files detected; skipping ruff check\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "no python files")
+
+        cmd = [ruff, "check", self.target]
+        header = f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n\n"
+
+        cp = subprocess.run(  # nosec B603
+            cmd, cwd=str(ctx.root), text=True, capture_output=True, check=False
+        )
+        text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+        out.write_text(ctx.redact_text(text), encoding="utf-8")
+
+        dur = int(time.time() - start)
+        # ruff nonzero = lint failures; that’s *valuable*, but for bundling we record it.
+        note = "" if cp.returncode == 0 else f"exit={cp.returncode} (lint findings)"
+        return StepResult(self.name, "PASS", dur, note)
+
+
+@dataclass
+class RuffFormatCheckStep:
+    name: str = "ruff format --check"
+    target: str = "."
+    outfile: str = "logs/32_ruff_format_check.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        ruff = which("ruff")
+        if not ruff:
+            out.write_text(
+                "ruff not found; skipping (pip install ruff)\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing ruff")
+
+        if not _repo_has_py_files(ctx.root):
+            out.write_text(
+                "no .py files detected; skipping ruff format check\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "no python files")
+
+        cmd = [ruff, "format", "--check", self.target]
+        header = f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n\n"
+
+        cp = subprocess.run(  # nosec B603
+            cmd, cwd=str(ctx.root), text=True, capture_output=True, check=False
+        )
+        text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+        out.write_text(ctx.redact_text(text), encoding="utf-8")
+
+        dur = int(time.time() - start)
+        note = "" if cp.returncode == 0 else f"exit={cp.returncode} (format drift)"
+        return StepResult(self.name, "PASS", dur, note)

pybundle/steps/shell.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for tool execution, paths validated
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+
+
+@dataclass
+class ShellStep:
+    name: str
+    outfile_rel: str
+    cmd: list[str]
+    cwd_is_root: bool = True
+    allow_fail: bool = True
+    require_cmd: str | None = None
+
+    @property
+    def out_rel(self) -> str:
+        return self.outfile_rel
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        if self.require_cmd and not getattr(ctx.tools, self.require_cmd, None):
+            out = ctx.workdir / self.outfile_rel
+            out.parent.mkdir(parents=True, exist_ok=True)
+            out.write_text(
+                f"{self.require_cmd} not found; skipping\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, f"missing {self.require_cmd}")
+
+        # Resolve command path if the first element matches a tool name
+        cmd = list(self.cmd)
+        if cmd and self.require_cmd:
+            tool_path = getattr(ctx.tools, self.require_cmd, None)
+            if tool_path and cmd[0] in [self.require_cmd, "python", "python3"]:
+                cmd[0] = tool_path
+
+        out = ctx.workdir / self.outfile_rel
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        start = time.time()
+        header = (
+            f"## PWD: {ctx.root if self.cwd_is_root else Path.cwd()}\n"
+            f"## CMD: {' '.join(cmd)}\n\n"
+        )
+
+        try:
+            cp = subprocess.run(  # nosec B603
+                cmd,
+                cwd=str(ctx.root) if self.cwd_is_root else None,
+                text=True,
+                capture_output=True,
+                check=False,
+            )
+            text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+            out.write_text(ctx.redact_text(text), encoding="utf-8")
+            status = (
+                "PASS"
+                if cp.returncode == 0
+                else ("FAIL" if not self.allow_fail else "PASS")
+            )
+            note = "" if cp.returncode == 0 else f"exit={cp.returncode}"
+        except Exception as e:
+            out.write_text(
+                ctx.redact_text(header + f"\nEXCEPTION: {e}\n"), encoding="utf-8"
+            )
+            status = "FAIL" if not self.allow_fail else "PASS"
+            note = str(e)
+
+        dur = int(time.time() - start)
+        return StepResult(self.name, status, dur, note)