gwc-pybundle 1.4.5__py3-none-any.whl

pybundle/steps/context_expand.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import ast
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+
+
+def _read_lines(p: Path) -> list[str]:
+    if not p.is_file():
+        return []
+    return [
+        ln.strip()
+        for ln in p.read_text(encoding="utf-8", errors="replace").splitlines()
+        if ln.strip()
+    ]
+
+
+def _is_under(root: Path, p: Path) -> bool:
+    try:
+        p.resolve().relative_to(root.resolve())
+        return True
+    except Exception:
+        return False
+
+
+def _copy_file(src: Path, dst: Path) -> bool:
+    try:
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        dst.write_bytes(src.read_bytes())
+        return True
+    except Exception:
+        return False
+
+
+def _find_repo_candidates(root: Path) -> list[Path]:
+    cands = [root]
+    if (root / "src").is_dir():
+        cands.append(root / "src")
+    return cands
+
+
+def _module_to_path(roots: list[Path], module: str) -> Path | None:
+    """
+    Resolve an absolute module like 'pkg.sub' to a file inside repo roots:
+      - <root>/pkg/sub.py
+      - <root>/pkg/sub/__init__.py
+    """
+    parts = module.split(".")
+    for r in roots:
+        f1 = r.joinpath(*parts).with_suffix(".py")
+        if f1.is_file():
+            return f1
+        f2 = r.joinpath(*parts) / "__init__.py"
+        if f2.is_file():
+            return f2
+    return None
+
+
+def _relative_module_to_path(
+    roots: list[Path], base_file: Path, module: str | None, level: int
+) -> Path | None:
+    """
+    Resolve relative imports like:
+      from . import x      (level=1, module=None)
+      from ..foo import y  (level=2, module="foo")
+    """
+    # Find the package directory for base_file
+    base_dir = base_file.parent
+
+    # Move up `level` package levels
+    rel_dir = base_dir
+    for _ in range(level):
+        rel_dir = rel_dir.parent
+
+    if module:
+        target = rel_dir.joinpath(*module.split("."))
+    else:
+        target = rel_dir
+
+    # Try module as file or package
+    f1 = target.with_suffix(".py")
+    if f1.is_file():
+        return f1
+    f2 = target / "__init__.py"
+    if f2.is_file():
+        return f2
+
+    # If relative resolution fails, try absolute resolution as fallback
+    if module:
+        return _module_to_path(roots, module)
+    return None
+
+
+def _extract_import_modules(py_file: Path) -> set[tuple[str | None, int]]:
+    """
+    Returns a set of (module, level) pairs:
+      - absolute imports: (module, 0)
+      - relative imports: (module, level>=1)
+    module can be None for `from . import x` style.
+    """
+    out: set[tuple[str | None, int]] = set()
+    try:
+        src = py_file.read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(src)
+    except Exception:
+        return out
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name:
+                    out.add((alias.name, 0))
+        elif isinstance(node, ast.ImportFrom):
+            # node.module can be None (from . import x)
+            lvl = int(getattr(node, "level", 0) or 0)
+            mod = node.module
+            if mod:
+                out.add((mod, lvl))
+            else:
+                # still useful; we can resolve to the package itself for context
+                out.add((None, lvl))
+    return out
+
+
+def _add_package_chain(files: set[Path], root: Path, py: Path) -> None:
+    """
+    Add __init__.py from file's dir up to repo root.
+    """
+    cur = py.parent
+    root_res = root.resolve()
+    while True:
+        initp = cur / "__init__.py"
+        if initp.is_file():
+            files.add(initp)
+        if cur.resolve() == root_res:
+            break
+        if not _is_under(root, cur):
+            break
+        cur = cur.parent
+
+
+def _add_conftest_chain(files: set[Path], root: Path, py: Path) -> None:
+    """
+    Add conftest.py from file's dir up to repo root (pytest glue).
+    """
+    cur = py.parent
+    root_res = root.resolve()
+    while True:
+        cp = cur / "conftest.py"
+        if cp.is_file():
+            files.add(cp)
+        if cur.resolve() == root_res:
+            break
+        if not _is_under(root, cur):
+            break
+        cur = cur.parent
+
+
+@dataclass
+class ErrorContextExpandStep:
+    name: str = "expand error context"
+    depth: int = 2
+    max_files: int = 600
+    # reads this list produced by step 8
+    source_list_file: str = "error_files_from_logs.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        roots = _find_repo_candidates(ctx.root)
+
+        list_path = ctx.workdir / self.source_list_file
+        rels = _read_lines(list_path)
+
+        dest_root = ctx.srcdir / "_error_context"
+        dest_root.mkdir(parents=True, exist_ok=True)
+
+        to_copy: set[Path] = set()
+        queue: list[tuple[Path, int]] = []
+
+        # Seed with referenced python files only
+        for rel_str in rels:
+            p = (ctx.root / rel_str).resolve()
+            if p.is_file() and p.suffix == ".py" and _is_under(ctx.root, p):
+                queue.append((p, 0))
+                to_copy.add(p)
+
+        visited: set[Path] = set()
+
+        while queue and len(to_copy) < self.max_files:
+            py_file, d = queue.pop(0)
+            if py_file in visited:
+                continue
+            visited.add(py_file)
+
+            # add pytest + package glue around this file
+            _add_package_chain(to_copy, ctx.root, py_file)
+            _add_conftest_chain(to_copy, ctx.root, py_file)
+
+            if d >= self.depth:
+                continue
+
+            # parse imports and resolve to repo files
+            for mod, level in _extract_import_modules(py_file):
+                target: Path | None
+                if level and level > 0:
+                    target = _relative_module_to_path(roots, py_file, mod, level)
+                else:
+                    if not mod:
+                        continue
+                    target = _module_to_path(roots, mod)
+
+                if target and target.is_file() and _is_under(ctx.root, target):
+                    if target.suffix == ".py":
+                        if target not in to_copy:
+                            to_copy.add(target)
+                        queue.append((target, d + 1))
+
+                if len(to_copy) >= self.max_files:
+                    break
+
+        # Always include top-level config files if present (small but high value)
+        for cfg in [
+            "pyproject.toml",
+            "mypy.ini",
+            "ruff.toml",
+            ".ruff.toml",
+            "pytest.ini",
+            "setup.cfg",
+            "requirements.txt",
+        ]:
+            p = ctx.root / cfg
+            if p.is_file():
+                to_copy.add(p)
+
+        copied = 0
+        for p in sorted(to_copy):
+            if copied >= self.max_files:
+                break
+            # copy under src/_error_context/<repo-relative-path>
+            try:
+                rel_path = p.resolve().relative_to(ctx.root.resolve())
+            except Exception:
+                continue
+            dst = dest_root / rel_path
+            if _copy_file(p, dst):
+                copied += 1
+
+        report = ctx.metadir / "61_error_context_report.txt"
+        report.write_text(
+            "\n".join(
+                [
+                    f"seed_files={len([r for r in rels if r.endswith('.py')])}",
+                    f"depth={self.depth}",
+                    f"max_files={self.max_files}",
+                    f"resolved_total={len(to_copy)}",
+                    f"copied={copied}",
+                    "dest=src/_error_context",
+                ]
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+
+        dur = int(time.time() - start)
+        note = f"resolved={len(to_copy)} copied={copied}"
+        if copied >= self.max_files:
+            note += " (HIT MAX)"
+        return StepResult(self.name, "PASS", dur, note)

pybundle/steps/copy_pack.py

@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+import os
+import shutil
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from pybundle.context import BundleContext
+from pybundle.policy import AIContextPolicy, PathFilter
+
+
+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 _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, int]:
+    """
+    Copy directory tree while pruning excluded directories and skipping excluded files.
+
+    Returns: (files_copied, dirs_pruned, files_excluded)
+    """
+    seen_files = 0
+    files_copied = 0
+    pruned_dirs = 0
+
+    for dirpath, dirnames, filenames in os.walk(src_dir):
+        dp = Path(dirpath)
+        rel_dir = dp.relative_to(src_dir)
+
+        # prune dirs in-place so os.walk doesn't descend into them
+        kept: list[str] = []
+        for d in dirnames:
+            if filt.should_prune_dir(dp, d):
+                pruned_dirs += 1
+                continue
+            kept.append(d)
+        dirnames[:] = kept
+
+        for fn in filenames:
+            seen_files += 1
+            sp = dp / fn
+            rel_file = rel_dir / fn
+
+            # single source of truth: PathFilter handles excluded dirs, patterns, and extensions
+            if not filt.should_include_file(root, sp):
+                continue
+
+            tp = dst_dir / rel_file
+            try:
+                _safe_copy_file(sp, tp)
+            except OSError:
+                continue
+
+            files_copied += 1
+
+    files_excluded = max(0, seen_files - files_copied)
+    return files_copied, pruned_dirs, files_excluded
+
+
+def _guess_package_dirs(root: Path, filt: "PathFilter") -> list[Path]:
+    out: list[Path] = []
+    for p in sorted(root.iterdir()):
+        if not p.is_dir():
+            continue
+        if p.name.startswith("."):
+            continue
+        if filt.should_prune_dir(root, p.name):
+            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)
+        )
+        exclude_patterns = set(policy.exclude_patterns)
+        filt = PathFilter(
+            exclude_dirs=exclude,
+            exclude_patterns=exclude_patterns,
+            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
+        excluded_total = 0
+
+        # 1) Include well-known top-level files if present
+        for rel_file in include_files:
+            if copied >= self.max_files:
+                break
+
+            sp = ctx.root / rel_file
+            if not sp.is_file():
+                continue
+            if not filt.should_include_file(ctx.root, sp):
+                continue
+
+            try:
+                _safe_copy_file(sp, dst_root / rel_file)
+                copied += 1
+                if copied >= self.max_files:
+                    break
+            except OSError:
+                pass
+
+        # 2) Include common top-level dirs (src/tests/tools)
+        for rel_dir in include_dirs:
+            sp = ctx.root / rel_dir
+            if not sp.is_dir():
+                continue
+
+            # policy prune (exact + patterns + venv detection inside PathFilter)
+            if filt.should_prune_dir(ctx.root, rel_dir):
+                pruned += 1
+                continue
+
+            # extra-strong venv detection for oddly-named envs
+            if _is_venv_root(sp):
+                pruned += 1
+                continue
+
+            files_copied, dirs_pruned, files_excluded = _copy_tree_filtered(
+                ctx.root, sp, dst_root / rel_dir, filt
+            )
+            copied += files_copied
+            pruned += dirs_pruned
+            excluded_total += files_excluded
+
+            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, filt):
+                rel_pkg_name = pkg_dir.name
+                if (dst_root / rel_pkg_name).exists():
+                    continue
+                files_copied, dirs_pruned, files_excluded = _copy_tree_filtered(
+                    ctx.root, pkg_dir, dst_root / rel_pkg_name, filt
+                )
+                copied += files_copied
+                pruned += dirs_pruned
+                excluded_total += files_excluded
+                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_under_venv(ctx.root, rel_path):
+                            pruned += 1
+                            continue
+
+                        dst = dst_root / rel_path
+                        if dst.exists():
+                            continue
+
+                        if sp.is_file():
+                            if not filt.should_include_file(ctx.root, sp):
+                                continue
+                            _safe_copy_file(sp, dst)
+                            copied += 1
+
+                        elif sp.is_dir():
+                            # prune dir itself before copying
+                            parent = (
+                                ctx.root
+                                if rel_path.parent == Path(".")
+                                else (ctx.root / rel_path.parent)
+                            )
+                            if filt.should_prune_dir(parent, rel_path.name):
+                                pruned += 1
+                                continue
+                            if _is_venv_root(sp):
+                                pruned += 1
+                                continue
+
+                            files_copied, dirs_pruned, files_excluded = (
+                                _copy_tree_filtered(
+                                    ctx.root, sp, dst_root / rel_path, filt
+                                )
+                            )
+                            copied += files_copied
+                            pruned += dirs_pruned
+                            excluded_total += files_excluded
+
+                        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}\n"
+            f"excluded_files={excluded_total}\n"
+            f"pruned_dirs={pruned}\n"
+            f"max_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/coverage.py

@@ -0,0 +1,101 @@
+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 _has_pytest(root: Path) -> bool:
+    """Check if pytest is likely used (tests exist or pytest in deps)."""
+    # Look for common test directories (exclude venv)
+    for test_dir in ["tests", "test"]:
+        test_path = root / test_dir
+        if test_path.is_dir():
+            # Make sure it's not inside a venv
+            if not any(
+                p.name.endswith("venv") or p.name.startswith(".")
+                for p in test_path.parents
+            ):
+                return True
+
+    # Look for test files in the project root and immediate subdirectories
+    # (not deep recursion to avoid finding venv tests)
+    for pattern in ["test_*.py", "*_test.py"]:
+        for p in root.glob(pattern):
+            return True
+        # Check one level deep
+        for subdir in root.iterdir():
+            if (
+                subdir.is_dir()
+                and not subdir.name.startswith(".")
+                and not subdir.name.endswith("venv")
+            ):
+                for p in subdir.glob(pattern):
+                    return True
+
+    return False
+
+
+@dataclass
+class CoverageStep:
+    name: str = "coverage"
+    outfile: str = "logs/35_coverage.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        # Check for pytest first (since we use pytest-cov)
+        pytest_bin = which("pytest")
+        if not pytest_bin:
+            out.write_text(
+                "pytest not found; skipping coverage (pip install pytest pytest-cov)\n",
+                encoding="utf-8",
+            )
+            return StepResult(self.name, "SKIP", 0, "missing pytest")
+
+        # Check if there are tests to run
+        if not _has_pytest(ctx.root):
+            out.write_text("no tests detected; skipping coverage\n", encoding="utf-8")
+            return StepResult(self.name, "SKIP", 0, "no tests")
+
+        # Run pytest with coverage (including branch coverage for v1.4.1+)
+        cmd = [
+            pytest_bin,
+            "--cov",
+            "--cov-branch",  # Enable branch coverage (v1.4.1+)
+            "--cov-report=term-missing:skip-covered",
+            "--no-cov-on-fail",
+            "-q",
+        ]
+        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
+        )
+
+        # Combine stdout and stderr
+        text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+
+        # If pytest-cov is not installed, provide helpful message
+        if "pytest: error: unrecognized arguments: --cov" in text:
+            text = (
+                header
+                + "pytest-cov not found; install with: pip install pytest-cov\n\n"
+                + text
+            )
+            out.write_text(ctx.redact_text(text), encoding="utf-8")
+            return StepResult(self.name, "SKIP", 0, "missing pytest-cov")
+
+        out.write_text(ctx.redact_text(text), encoding="utf-8")
+
+        dur = int(time.time() - start)
+        # Non-zero exit means test failures or coverage threshold not met
+        note = "" if cp.returncode == 0 else f"exit={cp.returncode}"
+        return StepResult(self.name, "PASS", dur, note)