gwc-pybundle 0.4.2__py3-none-any.whl

pybundle/steps/copy_pack.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import os
+import shutil
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..policy import AIContextPolicy, PathFilter
+
+
+DEFAULT_EXCLUDE_DIRS = {
+    ".git",
+    ".venv",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".pytest_cache",
+    "__pycache__",
+    "node_modules",
+    "dist",
+    "build",
+    "target",
+    ".next",
+    ".nuxt",
+    "artifacts",
+    ".cache",
+}
+
+DEFAULT_INCLUDE_FILES = [
+    "pyproject.toml",
+    "requirements.txt",
+    "poetry.lock",
+    "pdm.lock",
+    "uv.lock",
+    "setup.cfg",
+    "setup.py",
+    "mypy.ini",
+    "ruff.toml",
+    ".ruff.toml",
+    "pytest.ini",
+    "tox.ini",
+    ".python-version",
+    "README.md",
+    "README.rst",
+    "README.txt",
+    "CHANGELOG.md",
+    "LICENSE",
+    "LICENSE.md",
+    ".tox",
+    ".nox",
+    ".direnv",
+]
+
+DEFAULT_INCLUDE_DIRS = [
+    "src",
+    "tests",
+    "tools",
+    "docs",
+    ".github",
+]
+
+DEFAULT_INCLUDE_GLOBS = [
+    # common python project layouts
+    "*.py",
+    "*/**/*.py",
+    # templates/assets if present
+    "templates/**/*",
+    "static/**/*",
+]
+
+def _is_venv_root(p: Path) -> bool:
+    if not p.is_dir():
+        return False
+
+    # Strong marker: standard venv metadata
+    if (p / "pyvenv.cfg").is_file():
+        return True
+
+    # Typical venv executables (Linux/macOS)
+    if (p / "bin").is_dir():
+        # venv/virtualenv always has python here
+        if (p / "bin" / "python").exists() or (p / "bin" / "python3").exists():
+            # activation script is common but not guaranteed; still strong signal
+            if (p / "bin" / "activate").is_file():
+                return True
+            # also accept presence of site-packages under lib
+            if any((p / "lib").glob("python*/site-packages")):
+                return True
+
+    # Windows venv layout
+    if (p / "Scripts").is_dir():
+        if (p / "Scripts" / "python.exe").is_file() or (p / "Scripts" / "python").exists():
+            if (p / "Scripts" / "activate").is_file():
+                return True
+            if (p / "Lib" / "site-packages").is_dir():
+                return True
+
+    # Some virtualenvs keep a .Python marker (macOS, older tooling)
+    if (p / ".Python").exists():
+        return True
+
+    return False
+
+def _is_under_venv(root: Path, rel_path: Path) -> bool:
+    # walk ancestors: a/b/c.py -> check a, a/b, a/b/c
+    cur = root
+    for part in rel_path.parts:
+        cur = cur / part
+        if _is_venv_root(cur):
+            return True
+    return False
+
+def _is_excluded_path(rel: Path, exclude_dirs: set[str]) -> bool:
+    for part in rel.parts:
+        if part in exclude_dirs:
+            return True
+    return False
+
+def _safe_copy_file(src: Path, dst: Path) -> None:
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    # preserve mode + timestamps where possible
+    shutil.copy2(src, dst)
+
+def _copy_tree_filtered(
+    root: Path, src_dir: Path, dst_dir: Path, filt: PathFilter
+) -> tuple[int, int]:
+    """
+    Copy directory tree while pruning excluded directories and skipping excluded files.
+    Returns: (files_copied, dirs_pruned)
+    """
+    files = 0
+    pruned = 0
+
+    for dirpath, dirnames, filenames in os.walk(src_dir):
+        dp = Path(dirpath)
+        rel = dp.relative_to(src_dir)
+
+        # prune dirs (name-based + venv-structure)
+        kept: list[str] = []
+        for d in dirnames:
+            if filt.should_prune_dir(dp, d):
+                pruned += 1
+                continue
+            kept.append(d)
+        dirnames[:] = kept
+
+        for fn in filenames:
+            sp = dp / fn
+
+            # apply policy filter (extensions + excluded dirs, etc.)
+            if not filt.should_include_file(root, sp):
+                continue
+
+            tp = dst_dir / rel / fn
+            try:
+                _safe_copy_file(sp, tp)
+                files += 1
+            except OSError:
+                continue
+
+    return files, pruned
+
+def _guess_package_dirs(root: Path, exclude_dirs: set[str]) -> list[Path]:
+    """
+    Heuristic: top-level dirs containing __init__.py are packages.
+    """
+    out: list[Path] = []
+    for p in sorted(root.iterdir()):
+        if not p.is_dir():
+            continue
+        if p.name.startswith("."):
+            continue
+        if p.name in exclude_dirs:
+            continue
+        if (p / "__init__.py").is_file():
+            out.append(p)
+    return out
+
+@dataclass
+class CuratedCopyStep:
+    name: str = "copy curated source pack"
+    include_files: list[str] | None = None
+    include_dirs: list[str] | None = None
+    include_globs: list[str] | None = None
+    exclude_dirs: set[str] | None = None
+    max_files: int = 20000
+    policy: AIContextPolicy | None = None
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        dst_root = ctx.srcdir  # bundle/src
+        dst_root.mkdir(parents=True, exist_ok=True)
+
+        policy = self.policy or AIContextPolicy()
+
+        exclude = set(self.exclude_dirs) if self.exclude_dirs else set(policy.exclude_dirs)
+        filt = PathFilter(exclude_dirs=exclude, exclude_file_exts=set(policy.exclude_file_exts))
+        include_files = self.include_files or list(policy.include_files)
+        include_dirs = self.include_dirs or list(policy.include_dirs)
+        include_globs = self.include_globs or list(policy.include_globs)
+
+        copied = 0
+        pruned = 0
+
+        # 1) Include well-known top-level files if present
+        for rel_file in include_files:
+            sp = ctx.root / rel_file
+            if not filt.should_include_file(ctx.root, sp):
+                continue
+            if sp.is_file():
+                if _is_excluded_path(Path(rel_file), exclude):
+                    continue
+                try:
+                    _safe_copy_file(sp, dst_root / rel_file)
+                    copied += 1
+                except OSError:
+                    pass
+
+        # 2) Include common top-level dirs (src/tests/tools)
+        for rel_dir in include_dirs:
+            sp = ctx.root / rel_dir
+            if sp.is_dir() and rel_dir not in exclude:
+                if _is_venv_root(sp):
+                    pruned += 1
+                    continue
+                if _is_excluded_path(Path(rel_dir), exclude):
+                    continue
+                files_copied, dirs_pruned = _copy_tree_filtered(
+                    ctx.root, sp, dst_root / rel_dir, filt
+                )
+                copied += files_copied
+                pruned += dirs_pruned
+                if copied >= self.max_files:
+                    break
+
+        # 3) Include detected package dirs at root (if not already copied)
+        if copied < self.max_files:
+            for pkg_dir in _guess_package_dirs(ctx.root, exclude):
+                rel_pkg_name = pkg_dir.name
+                if (dst_root / rel_pkg_name).exists():
+                    continue
+                files_copied, dirs_pruned = _copy_tree_filtered(
+                    ctx.root, pkg_dir, dst_root / rel_pkg_name, filt
+                )
+                copied += files_copied
+                pruned += dirs_pruned
+                if copied >= self.max_files:
+                    break
+
+        # 4) Optional globs (best-effort; avoid deep explosion by pruning excluded dirs)
+        # We’ll apply globs but skip anything under excluded dirs.
+        if copied < self.max_files:
+            for g in include_globs:
+                for sp in ctx.root.glob(g):
+                    try:
+                        if not sp.exists():
+                            continue
+                        rel_path = sp.relative_to(ctx.root)
+                        if _is_excluded_path(rel_path, exclude):
+                            continue
+
+                        if _is_under_venv(ctx.root, rel_path):
+                            pruned += 1
+                            continue
+
+                        dst = dst_root / rel_path
+                        if dst.exists():
+                            continue
+
+                        if sp.is_file():
+                            _safe_copy_file(sp, dst)
+                            copied += 1
+                        elif sp.is_dir():
+                            files_copied, dirs_pruned = _copy_tree_filtered(
+                                ctx.root, sp, dst_root / rel_path, filt
+                            )
+                            copied += files_copied
+                            pruned += dirs_pruned
+                        if copied >= self.max_files:
+                            break
+                    except Exception:
+                        continue
+                if copied >= self.max_files:
+                    break
+
+        # write a short manifest for sanity
+        manifest = ctx.workdir / "meta" / "50_copy_manifest.txt"
+        manifest.parent.mkdir(parents=True, exist_ok=True)
+        manifest.write_text(
+            f"copied_files={copied}\npruned_dirs={pruned}\nmax_files={self.max_files}\n",
+            encoding="utf-8",
+        )
+
+        dur = int(time.time() - start)
+        note = f"copied={copied} pruned={pruned}"
+        if copied >= self.max_files:
+            note += " (HIT MAX)"
+        return StepResult(self.name, "PASS", dur, note)

pybundle/steps/error_refs.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import re
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+
+
+DEFAULT_EXCLUDE_PREFIXES = (
+    ".git/",
+    ".venv/",
+    ".mypy_cache/",
+    ".ruff_cache/",
+    ".pytest_cache/",
+    "__pycache__/",
+    "node_modules/",
+    "dist/",
+    "build/",
+    "artifacts/",
+)
+
+# Patterns based on your bash sed rules:
+# 1) tool-style: path:line(:col)...
+_RE_COLON_LINE = re.compile(r"^([A-Za-z0-9_.\/-]+\.[A-Za-z0-9]+):\d+(?::\d+)?\b.*$")
+
+# 2) pytest traceback: File "path", line N
+_RE_PYTEST_FILE = re.compile(r'^\s*File "([^"]+)", line \d+\b.*$')
+
+# 3) mypy: (optional "mypy:") ./path:line: (error|note|warning):
+_RE_MYPY_LINE = re.compile(
+    r"^(?:mypy:\s*)?(?:\./)?([A-Za-z0-9_.\/-]+\.[A-Za-z0-9]+):\d+:\s*(?:error|note|warning):.*$"
+)
+
+# 4) mypy rare: path: (error|note|warning): ...
+_RE_MYPY_NOLINE = re.compile(
+    r"^(?:mypy:\s*)?(?:\./)?([A-Za-z0-9_.\/-]+\.[A-Za-z0-9]+):\s*(?:error|note|warning):.*$"
+)
+
+
+def _normalize_to_repo_rel(root: Path, p: str) -> str | None:
+    p = p.strip()
+    if not p:
+        return None
+
+    # remove leading ./ for consistency
+    if p.startswith("./"):
+        p = p[2:]
+
+    # absolute path -> must be under repo root
+    if p.startswith("/"):
+        try:
+            rp = Path(p).resolve()
+            rr = rp.relative_to(root.resolve())
+            return str(rr).replace("\\", "/")
+        except Exception:
+            return None
+
+    # relative path
+    return p.replace("\\", "/")
+
+
+def _is_allowed_repo_file(root: Path, rel: str) -> bool:
+    rel = rel.lstrip("./")
+    if not rel or rel.endswith("/"):
+        return False
+
+    # exclude common junk
+    for pref in DEFAULT_EXCLUDE_PREFIXES:
+        if rel.startswith(pref):
+            return False
+    if "/__pycache__/" in f"/{rel}/":
+        return False
+
+    # must exist and be a file inside repo
+    fp = (root / rel).resolve()
+    try:
+        fp.relative_to(root.resolve())
+    except Exception:
+        return False
+
+    return fp.is_file()
+
+
+def _extract_paths_from_text(text: str) -> list[str]:
+    out: list[str] = []
+    for line in text.splitlines():
+        m = _RE_COLON_LINE.match(line)
+        if m:
+            out.append(m.group(1))
+            continue
+
+        m = _RE_PYTEST_FILE.match(line)
+        if m:
+            out.append(m.group(1))
+            continue
+
+        m = _RE_MYPY_LINE.match(line)
+        if m:
+            out.append(m.group(1))
+            continue
+
+        m = _RE_MYPY_NOLINE.match(line)
+        if m:
+            out.append(m.group(1))
+            continue
+
+    return out
+
+
+@dataclass
+class ErrorReferencedFilesStep:
+    name: str = "collect error-referenced files"
+    max_files: int = 250
+    # Paths are relative to the bundle workdir
+    log_files: list[str] | None = None
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+
+        # Default set aligned to our step numbers
+        log_files = self.log_files or [
+            "logs/31_ruff_check.txt",
+            "logs/32_ruff_format_check.txt",
+            "logs/33_mypy.txt",
+            "logs/34_pytest_q.txt",
+        ]
+
+        out_list = ctx.workdir / "error_files_from_logs.txt"
+        out_count = ctx.workdir / "error_refs_count.txt"
+        report = ctx.metadir / "60_error_refs_report.txt"
+
+        dest_root = ctx.srcdir / "_error_refs"
+        dest_root.mkdir(parents=True, exist_ok=True)
+
+        # Collect candidate paths
+        candidates: set[str] = set()
+        scanned = 0
+        missing_logs = 0
+
+        for lf in log_files:
+            lp = ctx.workdir / lf
+            if not lp.is_file():
+                missing_logs += 1
+                continue
+            scanned += 1
+            try:
+                txt = lp.read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                continue
+
+            for raw in _extract_paths_from_text(txt):
+                norm = _normalize_to_repo_rel(ctx.root, raw)
+                if norm:
+                    candidates.add(norm)
+
+        # Normalize / filter to real repo files
+        allowed = sorted([p for p in candidates if _is_allowed_repo_file(ctx.root, p)])
+
+        # Write list file (even if empty)
+        out_list.write_text(
+            "\n".join(allowed) + ("\n" if allowed else ""), encoding="utf-8"
+        )
+
+        # Copy up to max_files
+        copied = 0
+        for rel in allowed:
+            if copied >= self.max_files:
+                break
+            src = ctx.root / rel
+            dst = dest_root / rel
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                # preserve mode/timestamps
+                dst.write_bytes(src.read_bytes())
+                copied += 1
+            except Exception:
+                continue
+
+        out_count.write_text(f"{copied}\n", encoding="utf-8")
+
+        report.write_text(
+            "\n".join(
+                [
+                    f"scanned_logs={scanned}",
+                    f"missing_logs={missing_logs}",
+                    f"candidates_total={len(candidates)}",
+                    f"allowed_repo_files={len(allowed)}",
+                    f"copied={copied}",
+                    f"max_files={self.max_files}",
+                    "dest=src/_error_refs",
+                ]
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+
+        dur = int(time.time() - start)
+        note = f"allowed={len(allowed)} copied={copied}"
+        if copied >= self.max_files:
+            note += " (HIT MAX)"
+        return StepResult(self.name, "PASS", dur, note)

pybundle/steps/handoff_md.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import time
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .base import Step, StepResult
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _safe_read(path: Path) -> str:
+    if not path.exists():
+        return f"(missing: {path.as_posix()})"
+    return path.read_text(encoding="utf-8", errors="replace").strip()
+
+
+def _tool_table(tools_obj: Any) -> list[str]:
+    d = (
+        asdict(tools_obj)
+        if hasattr(tools_obj, "__dataclass_fields__")
+        else dict(tools_obj)
+    )
+    lines = ["| Tool | Status |", "|------|--------|"]
+    for k in sorted(d.keys()):
+        v = d[k]
+        if v:
+            lines.append(f"| `{k}` | ✅ `{v}` |")
+        else:
+            lines.append(f"| `{k}` | ❌ `<missing>` |")
+    return lines
+
+
+class HandoffMarkdownStep(Step):
+    name = "generate HANDOFF.md"
+
+    def run(self, ctx: Any) -> StepResult:
+        start = time.time()
+
+        created_utc = getattr(ctx, "created_utc", None) or _utc_now()
+        profile = getattr(ctx, "profile_name", "<unknown>")
+        root_path = Path(getattr(ctx, "root"))
+        project = root_path.name
+        root = str(root_path)
+        workdir_path = Path(getattr(ctx, "workdir"))
+        workdir = str(workdir_path)
+
+        # filenames fixed to match your repo
+        uname = _safe_read(workdir_path / "meta" / "21_uname.txt")
+        pyver = _safe_read(workdir_path / "meta" / "20_python_version.txt")
+
+        redact = bool(getattr(ctx, "redact", True))
+        redact_status = "enabled" if redact else "disabled"
+
+        results: list[Any] = list(getattr(ctx, "results", []))
+        pass_n = sum(1 for r in results if getattr(r, "status", "") == "PASS")
+        fail_n = sum(1 for r in results if getattr(r, "status", "") == "FAIL")
+        skip_n = sum(1 for r in results if getattr(r, "status", "") == "SKIP")
+        total_n = len(results)
+
+        overall = "FAIL" if fail_n else ("DEGRADED" if skip_n else "PASS")
+
+        # tool table
+        tools_obj = getattr(ctx, "tools", None) or getattr(ctx, "tooling", None)
+        tools_table = (
+            _tool_table(tools_obj) if tools_obj is not None else ["(no tools detected)"]
+        )
+
+        command_used = getattr(ctx, "command_used", "") or "(not captured)"
+
+        lines: list[str] = []
+        lines.append("# Bundle Handoff")
+        lines.append("")
+        lines.append("## Overview")
+        lines.append(
+            f"- **Bundle tool:** pybundle {getattr(ctx, 'version', '<unknown>')}"
+        )
+        lines.append(f"- **Profile:** {profile}")
+        lines.append(f"- **Created (UTC):** {created_utc}")
+        lines.append(f"- **Project:** {project}")
+        lines.append(f"- **Root:** {root}")
+        lines.append(f"- **Workdir:** {workdir}")
+        lines.append("")
+        lines.append("## System")
+        lines.append(f"- **OS:** {uname}")
+        lines.append(f"- **Python:** {pyver}")
+        lines.append(f"- **Redaction:** {redact_status}")
+        lines.append("")
+        lines.append("## At a glance")
+
+        roadmap_json = _safe_read(workdir_path / "meta" / "70_roadmap.json")
+        copy_manifest = _safe_read(workdir_path / "meta" / "50_copy_manifest.txt")
+        pip_freeze = _safe_read(workdir_path / "meta" / "22_pip_freeze.txt")
+
+        lines.append("## AI context summary")
+
+        copy_manifest = _safe_read(workdir_path / "meta" / "50_copy_manifest.txt").strip()
+        if copy_manifest:
+            lines.append("### Curated copy")
+            lines.append("```")
+            lines.append(copy_manifest)
+            lines.append("```")
+        else:
+            lines.append("- Curated copy manifest not found.")
+
+        roadmap_json = _safe_read(workdir_path / "meta" / "70_roadmap.json").strip()
+        if roadmap_json:
+            try:
+                import json
+                rj = json.loads(roadmap_json)
+                langs = set()
+                for n in rj.get("nodes", []):
+                    if isinstance(n, dict):
+                        lang = n.get("lang")
+                        if lang:
+                            langs.add(lang)
+                eps = rj.get("entrypoints", []) or []
+                lines.append(f"- **Languages detected:** {', '.join(sorted(langs)) if langs else '(none)'}")
+                if eps:
+                    lines.append("- **Entrypoints:**")
+                    for ep in eps[:10]:
+                        node = ep.get("node") if isinstance(ep, dict) else None
+                        reason = ep.get("reason") if isinstance(ep, dict) else None
+                        conf = ep.get("confidence") if isinstance(ep, dict) else None
+                        if node:
+                            extra = ""
+                            if reason is not None and conf is not None:
+                                extra = f" — {reason} ({conf}/3)"
+                            lines.append(f"  - `{node}`{extra}")
+                else:
+                    lines.append("- **Entrypoints:** (none detected)")
+            except Exception:
+                lines.append("- Roadmap JSON present but could not be parsed.")
+        else:
+            lines.append("- Roadmap not found.")
+
+        lines.append("")
+
+        lines.append(f"- **Overall status:** {overall}")
+        lines.append(
+            f"- **Steps:** {total_n} total — {pass_n} PASS, {fail_n} FAIL, {skip_n} SKIP"
+        )
+        lines.append("")
+        lines.append("## Tools")
+        lines.extend(tools_table)
+        lines.append("")
+        lines.append("## Command used")
+        lines.append("```bash")
+        lines.append(command_used)
+        lines.append("```")
+        lines.append("")
+        lines.append("## Reproduction")
+        lines.append("See **REPRO.md** for step-by-step reproduction instructions.")
+        lines.append("")
+
+        out_path = workdir_path / "HANDOFF.md"
+        out_path.write_text("\n".join(lines), encoding="utf-8")
+
+        secs = int(time.time() - start)
+        return StepResult(
+            name=self.name, status="PASS", seconds=secs, note="wrote HANDOFF.md"
+        )