gwc-pybundle 0.4.2__py3-none-any.whl

pybundle/steps/mypy.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+def _has_mypy_config(root: Path) -> bool:
+    if (root / "mypy.ini").is_file():
+        return True
+    if (root / "setup.cfg").is_file():
+        return True
+    if (root / "pyproject.toml").is_file():
+        # we don't parse TOML here; presence is enough for v1
+        return True
+    return False
+
+
+@dataclass
+class MypyStep:
+    name: str = "mypy"
+    target: str = "pybundle"
+    outfile: str = "logs/33_mypy.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        mypy = which("mypy")
+        if not mypy:
+            out.write_text(
+                "mypy not found; skipping (pip install mypy)\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing mypy")
+
+        if not _has_mypy_config(ctx.root):
+            out.write_text(
+                "no mypy config detected (mypy.ini/setup.cfg/pyproject.toml); skipping\n",
+                encoding="utf-8",
+            )
+            return StepResult(self.name, "SKIP", 0, "no config")
+
+        cmd = [mypy, "--exclude", "^artifacts/", self.target]
+        header = f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n\n"
+
+        cp = subprocess.run(
+            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} (type findings)"
+        return StepResult(self.name, "PASS", dur, note)

pybundle/steps/pytest.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+def _has_tests(root: Path) -> bool:
+    # common conventions
+    if (root / "tests").is_dir():
+        return True
+    # sometimes tests are inside the package
+    # (don’t walk the whole tree; just check a couple likely paths)
+    for candidate in ["src/tests", "app/tests"]:
+        if (root / candidate).is_dir():
+            return True
+    # any */tests at depth 2 is also a common pattern
+    for p in root.glob("*/tests"):
+        if p.is_dir():
+            return True
+    return False
+
+
+@dataclass
+class PytestStep:
+    name: str = "pytest"
+    args: list[str] | None = None
+    outfile: str = "logs/34_pytest_q.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        pytest_bin = which("pytest")
+        if not pytest_bin:
+            out.write_text(
+                "pytest not found; skipping (pip install pytest)\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing pytest")
+
+        if not _has_tests(ctx.root):
+            out.write_text(
+                "no tests directory detected; skipping pytest\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "no tests")
+
+        args = self.args or ["-q"]
+        cmd = [pytest_bin, *args]
+
+        header = f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n\n"
+
+        cp = subprocess.run(
+            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} (test failures)"
+        return StepResult(self.name, "PASS", dur, note)

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
+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(
+            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,158 @@
+from __future__ import annotations
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..roadmap_scan import build_roadmap
+from ..steps.copy_pack import DEFAULT_EXCLUDE_DIRS
+from ..policy import AIContextPolicy
+
+@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
+    max_files: int = 20000
+    policy: AIContextPolicy | None = None
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+
+        include_dirs = []
+        if self.include:
+            include_dirs = [ctx.root / p for p in self.include]
+        else:
+            # sane defaults: mimic your curated source approach
+            include_dirs: list[Path] = []
+            if self.include:
+                include_dirs = [ctx.root / p for p in self.include]
+            else:
+                # sane defaults: scan source trees, not the whole repo
+                candidates = [
+                    ctx.root / "src",
+                    ctx.root / "pybundle",        # in case this repo isn't src-layout
+                    ctx.root / "src-tauri",
+                    ctx.root / "frontend",
+                    ctx.root / "web",
+                    ctx.root / "ui",
+                    ctx.root / "templates",
+                    ctx.root / "static",
+                ]
+                include_dirs = [p for p in candidates if p.exists()]
+
+                # fallback if none exist
+                if not include_dirs:
+                    include_dirs = [ctx.root]
+
+        policy = self.policy or AIContextPolicy()
+        include_dirs = [p for p in policy.include_dir_candidates(ctx.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,
+            # later: depth=policy.roadmap_depth
+        )
+
+        # Write 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")
+
+        # Write Markdown (with Mermaid)
+        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), 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) -> str:
+        lines = []
+        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")
+
+        depth = 2
+        max_edges = 180
+        try:
+            # if policy is passed through, prefer it
+            if hasattr(self, "policy") and self.policy is not None:
+                depth = self.policy.roadmap_mermaid_depth
+                max_edges = self.policy.roadmap_mermaid_max_edges
+        except Exception:
+            pass
+
+        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, 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
+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(
+            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(
+            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)