gwc-pybundle 0.4.2__py3-none-any.whl

pybundle/cli.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import shlex
+
+from .context import BundleContext, RunOptions
+from .profiles import get_profile
+from .root_detect import detect_project_root
+from importlib.metadata import PackageNotFoundError, version as pkg_version
+from .runner import run_profile
+
+def get_version() -> str:
+    # 1) Canonical for installed distributions (including editable)
+    try:
+        return pkg_version("pybundle")
+    except PackageNotFoundError:
+        pass
+
+    # 2) Dev fallback: locate pyproject.toml by walking up from this file
+    try:
+        import tomllib  # py3.11+
+    except Exception:
+        return "unknown"
+
+    here = Path(__file__).resolve()
+    for parent in [here.parent] + list(here.parents):
+        pp = parent / "pyproject.toml"
+        if pp.is_file():
+            try:
+                data = tomllib.loads(pp.read_text(encoding="utf-8"))
+                return data.get("project", {}).get("version", "unknown")
+            except Exception:
+                return "unknown"
+
+    return "unknown"
+
+def add_common_args(sp: argparse.ArgumentParser) -> None:
+    sp.add_argument(
+        "--project-root",
+        type=Path,
+        default=None,
+        help="Explicit project root (skip auto-detect)",
+    )
+    sp.add_argument(
+        "--outdir",
+        type=Path,
+        default=None,
+        help="Output directory (default: <root>/artifacts)",
+    )
+    sp.add_argument("--name", default=None, help="Override archive name prefix")
+    sp.add_argument(
+        "--strict", action="store_true", help="Fail non-zero if any step fails"
+    )
+    sp.add_argument(
+        "--no-spinner", action="store_true", help="Disable spinner output (CI-friendly)"
+    )
+    sp.add_argument(
+        "--redact",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Redact secrets in logs/text",
+    )
+
+def _resolve_profile_defaults(profile: str, o: RunOptions) -> RunOptions:
+    if profile == "ai":
+        # AI defaults: skip slow/flake-prone tools unless explicitly enabled
+        return RunOptions(
+            **{
+              **o.__dict__,
+              "no_ruff":  o.no_ruff  if o.no_ruff  is not None else True,
+              "no_mypy":  o.no_mypy  if o.no_mypy  is not None else True,
+              "no_pytest":o.no_pytest if o.no_pytest is not None else True,
+              "no_rg":    o.no_rg    if o.no_rg    is not None else True,
+              "no_error_refs": o.no_error_refs if o.no_error_refs is not None else True,
+              "no_context":    o.no_context    if o.no_context    is not None else True,
+            }
+        )
+    return o
+
+def add_run_only_args(sp: argparse.ArgumentParser) -> None:
+    sp.add_argument(
+        "--format",
+        choices=["auto", "zip", "tar.gz"],
+        default="auto",
+        help="Archive format",
+    )
+    sp.add_argument(
+        "--clean-workdir",
+        action="store_true",
+        help="Delete expanded workdir after packaging",
+    )
+
+def add_knobs(sp: argparse.ArgumentParser) -> None:
+    # selective skips
+    sp.add_argument("--ruff", dest="no_ruff", action="store_false", default=None)
+    sp.add_argument("--no-ruff", dest="no_ruff", action="store_true", default=None)
+    sp.add_argument("--mypy", dest="no_mypy", action="store_false", default=None)
+    sp.add_argument("--no-mypy", dest="no_mypy", action="store_true", default=None)
+    sp.add_argument("--pytest", dest="no_pytest", action="store_false", default=None)
+    sp.add_argument("--no-pytest", dest="no_pytest", action="store_true", default=None)
+    sp.add_argument("--rg", dest="no_rg", action="store_false", default=None)
+    sp.add_argument("--no-rg", dest="no_rg", action="store_true", default=None)
+    sp.add_argument("--error-refs", dest="no_error_refs", action="store_false", default=None)
+    sp.add_argument("--no-error-refs", dest="no_error_refs", action="store_true", default=None)
+    sp.add_argument("--context", dest="no_context", action="store_false", default=None)
+    sp.add_argument("--no-context", dest="no_context", action="store_true", default=None)
+
+    # targets / args
+    sp.add_argument("--ruff-target", default=".")
+    sp.add_argument("--mypy-target", default=".")
+    sp.add_argument(
+        "--pytest-args",
+        default="-q",
+        help='Pytest args as a single string, e.g. "--maxfail=1 -q"',
+    )
+
+    # caps
+    sp.add_argument("--error-max-files", type=int, default=250)
+    sp.add_argument("--context-depth", type=int, default=2)
+    sp.add_argument("--context-max-files", type=int, default=600)
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="pybundle", description="Build portable diagnostic bundles for projects."
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("version", help="Show version")
+    sub.add_parser("list-profiles", help="List available profiles")
+
+    runp = sub.add_parser("run", help="Run a profile and build an archive")
+    runp.add_argument("profile", choices=["analysis", "debug", "backup", "ai"])
+    add_common_args(runp)
+    add_run_only_args(runp)
+    add_knobs(runp)
+
+    docp = sub.add_parser("doctor", help="Show tool availability and what would run")
+    docp.add_argument(
+        "profile", 
+        choices=["analysis", "debug", "backup", "ai"], 
+        nargs="?", 
+        default="analysis"
+    )
+    add_common_args(docp)
+    add_knobs(docp)
+
+    return p
+
+def _build_options(args) -> RunOptions:
+    pytest_args = (
+        shlex.split(args.pytest_args) if getattr(args, "pytest_args", None) else ["-q"]
+    )
+    return RunOptions(
+        no_ruff=getattr(args, "no_ruff", None),
+        no_mypy=getattr(args, "no_mypy", None),
+        no_pytest=getattr(args, "no_pytest", None),
+        no_rg=getattr(args, "no_rg", None),
+        no_error_refs=getattr(args, "no_error_refs", None),
+        no_context=getattr(args, "no_context", None),
+        ruff_target=getattr(args, "ruff_target", "."),
+        mypy_target=getattr(args, "mypy_target", "."),
+        pytest_args=pytest_args,
+        error_max_files=getattr(args, "error_max_files", 250),
+        context_depth=getattr(args, "context_depth", 2),
+        context_max_files=getattr(args, "context_max_files", 600),
+    )
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    if args.cmd == "version":
+        print(f"pybundle {get_version()}")
+        return 0
+
+    if args.cmd == "list-profiles":
+        print("ai        - AI-friendly context bundle (fast, low-flake defaults)")
+        print("backup    - portable snapshot (scaffold)")
+        print("analysis  - neutral diagnostic bundle (humans, tools, assistants)")
+        print("debug     - deeper diagnostics for developers")
+        return 0
+
+    # run + doctor need a root
+    root = args.project_root or detect_project_root(Path.cwd())
+    if root is None:
+        print("❌ Could not detect project root. Use --project-root PATH.")
+        return 20
+
+    outdir = args.outdir or (root / "artifacts")
+
+    options = _resolve_profile_defaults(args.profile, _build_options(args))
+    profile = get_profile(args.profile, options)
+
+    if args.cmd == "doctor":
+        ctx = BundleContext.create(
+            root=root,
+            outdir=outdir,
+            profile_name=args.profile,
+            archive_format="auto",
+            name_prefix=args.name,
+            strict=args.strict,
+            redact=args.redact,
+            spinner=not args.no_spinner,
+            keep_workdir=True,
+            options=options,
+        )
+        ctx.print_doctor(profile)
+        return 0
+
+    # cmd == run
+    keep_workdir = not args.clean_workdir
+
+    ctx = BundleContext.create(
+        root=root,
+        outdir=outdir,
+        profile_name=args.profile,
+        archive_format=args.format,
+        name_prefix=args.name,
+        strict=args.strict,
+        redact=args.redact,
+        spinner=not args.no_spinner,
+        keep_workdir=keep_workdir,
+        options=options,
+    )
+
+    return run_profile(ctx, profile)
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pybundle/context.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable, TYPE_CHECKING
+
+from .tools import which
+
+if TYPE_CHECKING:
+    from .steps.base import StepResult
+
+
+def fmt_tool(path: str | None) -> str:
+    if path:
+        return path
+    return "\x1b[31m<missing>\x1b[0m"
+
+
+@dataclass(frozen=True)
+class Tooling:
+    git: str | None
+    python: str | None
+    pip: str | None
+    zip: str | None
+    tar: str | None
+    uname: str | None
+
+    # analysis/debug tools
+    ruff: str | None
+    mypy: str | None
+    pytest: str | None
+    rg: str | None
+    tree: str | None
+    npm: str | None
+
+    @staticmethod
+    def detect() -> "Tooling":
+        return Tooling(
+            git=which("git"),
+            python=which("python") or which("python3"),
+            pip=which("pip") or which("pip3"),
+            zip=which("zip"),
+            tar=which("tar"),
+            uname=which("uname"),
+            ruff=which("ruff"),
+            mypy=which("mypy"),
+            pytest=which("pytest"),
+            rg=which("rg"),
+            tree=which("tree"),
+            npm=which("npm"),
+        )
+
+
+@dataclass(frozen=True)
+class RunOptions:
+    no_ruff: bool | None = None
+    no_mypy: bool | None = None
+    no_pytest: bool | None = None
+    no_rg: bool | None = None
+    no_error_refs: bool | None = None
+    no_context: bool | None = None
+    no_compileall: bool | None = None
+
+    ruff_target: str = "."
+    mypy_target: str = "."
+    pytest_args: list[str] = field(default_factory=lambda: ["-q"])
+
+    error_max_files: int = 250
+    context_depth: int = 2
+    context_max_files: int = 600
+
+
+@dataclass
+class BundleContext:
+    root: Path
+    options: RunOptions
+    outdir: Path
+    profile_name: str
+    ts: str
+    workdir: Path
+    srcdir: Path
+    logdir: Path
+    metadir: Path
+    runlog: Path
+    summary_json: Path
+    manifest_json: Path
+    archive_format: str
+    name_prefix: str
+    strict: bool
+    redact: bool
+    spinner: bool
+    keep_workdir: bool
+    tools: Tooling
+    results: list["StepResult"] = field(default_factory=list)
+    command_used: str = ""
+
+    def have(self, cmd: str) -> bool:
+        return getattr(self.tools, cmd, None) is not None
+
+    @staticmethod
+    def utc_ts() -> str:
+        return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        root: Path,
+        options: RunOptions | None = None,
+        outdir: Path,
+        profile_name: str,
+        archive_format: str,
+        name_prefix: str | None,
+        strict: bool,
+        redact: bool,
+        spinner: bool,
+        keep_workdir: bool,
+    ) -> "BundleContext":
+        ts = cls.utc_ts()
+        outdir.mkdir(parents=True, exist_ok=True)
+
+        workdir = outdir / f"pybundle_{profile_name}_{ts}"
+        srcdir = workdir / "src"
+        logdir = workdir / "logs"
+        metadir = workdir / "meta"
+
+        srcdir.mkdir(parents=True, exist_ok=True)
+        logdir.mkdir(parents=True, exist_ok=True)
+        metadir.mkdir(parents=True, exist_ok=True)
+
+        runlog = workdir / "RUN_LOG.txt"
+        summary_json = workdir / "SUMMARY.json"
+        manifest_json = workdir / "MANIFEST.json"
+
+        tools = Tooling.detect()
+        prefix = name_prefix or f"pybundle_{profile_name}_{ts}"
+
+        options = options or RunOptions()
+
+        return cls(
+            root=root,
+            options=options,
+            outdir=outdir,
+            profile_name=profile_name,
+            ts=ts,
+            workdir=workdir,
+            srcdir=srcdir,
+            logdir=logdir,
+            metadir=metadir,
+            runlog=runlog,
+            summary_json=summary_json,
+            manifest_json=manifest_json,
+            archive_format=archive_format,
+            name_prefix=prefix,
+            strict=strict,
+            redact=redact,
+            spinner=spinner,
+            keep_workdir=keep_workdir,
+            tools=tools,
+        )
+
+    def rel(self, p: Path) -> str:
+        try:
+            return str(p.relative_to(self.root))
+        except Exception:
+            return str(p)
+
+    def redact_text(self, text: str) -> str:
+        if not self.redact:
+            return text
+        # Minimal default redaction rules (you can expand with a rules file later)
+        rules: Iterable[tuple[str, str]] = [
+            (
+                r"(?i)(api[_-]?key)\s*[:=]\s*['\"]?([A-Za-z0-9_\-]{10,})",
+                r"\1=<REDACTED>",
+            ),
+            (r"(?i)(token)\s*[:=]\s*['\"]?([A-Za-z0-9_\-\.]{10,})", r"\1=<REDACTED>"),
+            (r"(?i)(password|passwd|pwd)\s*[:=]\s*['\"]?([^'\"\s]+)", r"\1=<REDACTED>"),
+            (r"(?i)(dsn)\s*[:=]\s*['\"]?([^'\"\s]+)", r"\1=<REDACTED>"),
+        ]
+        out = text
+        for pat, repl in rules:
+            out = re.sub(pat, repl, out)
+        return out
+
+    def write_runlog(self, line: str) -> None:
+        self.runlog.parent.mkdir(parents=True, exist_ok=True)
+        with self.runlog.open("a", encoding="utf-8") as f:
+            f.write(line.rstrip() + "\n")
+
+    def print_doctor(self, profile) -> None:
+        print(f"Root: {self.root}")
+        print(f"Out:  {self.outdir}\n")
+
+        # Tools (keep your existing output)
+        print("Tools:")
+        for k, v in asdict(self.tools).items():
+            print(f"{k:>8}: {fmt_tool(v)}")
+        print()
+
+        # Options (super useful)
+        print("Options:")
+        o = self.options
+        print(f"  ruff_target:       {o.ruff_target}")
+        print(f"  mypy_target:       {o.mypy_target}")
+        print(f"  pytest_args:       {' '.join(o.pytest_args)}")
+        print(f"  no_ruff:           {o.no_ruff}")
+        print(f"  no_mypy:           {o.no_mypy}")
+        print(f"  no_pytest:         {o.no_pytest}")
+        print(f"  no_rg:             {o.no_rg}")
+        print(f"  no_error_refs:     {o.no_error_refs}")
+        print(f"  no_context:        {o.no_context}")
+        print(f"  error_max_files:   {o.error_max_files}")
+        print(f"  context_depth:     {o.context_depth}")
+        print(f"  context_max_files: {o.context_max_files}")
+        print()
+
+        # Plan
+        from .doctor import plan_for_profile  # local import avoids circulars
+
+        plan = plan_for_profile(self, profile)
+
+        print(f"Plan ({profile.name}):")
+        for item in plan:
+            out = f" -> {item.out_rel}" if item.out_rel else ""
+            if item.status == "RUN":
+                print(f"  RUN  {item.name:<28}{out}")
+            else:
+                why = f" ({item.reason})" if item.reason else ""
+                print(f"  SKIP {item.name:<28}{out}{why}")

pybundle/doctor.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, TypeVar
+
+from .steps.shell import ShellStep
+from .steps.ruff import RuffCheckStep, RuffFormatCheckStep
+from .steps.mypy import MypyStep
+from .steps.pytest import PytestStep
+from .steps.rg_scans import RipgrepScanStep
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class PlanItem:
+    name: str
+    status: str  # "RUN" | "SKIP"
+    out_rel: str | None
+    reason: str
+
+
+EvalFn = Callable[[Any, T], PlanItem]
+
+
+def _out(step: Any) -> str | None:
+    return (
+        getattr(step, "out_rel", None)
+        or getattr(step, "outfile_rel", None)
+        or getattr(step, "outfile", None)
+    )
+
+
+def eval_shell(ctx: Any, step: ShellStep) -> PlanItem:
+    if step.require_cmd and not ctx.have(step.require_cmd):
+        return PlanItem(
+            step.name, "SKIP", _out(step), f"missing tool: {step.require_cmd}"
+        )
+    return PlanItem(step.name, "RUN", _out(step), "")
+
+
+def eval_ruff(ctx: Any, step: Any) -> PlanItem:
+    if ctx.options.no_ruff:
+        return PlanItem(step.name, "SKIP", _out(step), "disabled by --no-ruff")
+    if not ctx.have("ruff"):
+        return PlanItem(step.name, "SKIP", _out(step), "missing tool: ruff")
+    return PlanItem(step.name, "RUN", _out(step), "")
+
+
+def eval_mypy(ctx: Any, step: MypyStep) -> PlanItem:
+    if ctx.options.no_mypy:
+        return PlanItem(step.name, "SKIP", _out(step), "disabled by --no-mypy")
+    if not ctx.have("mypy"):
+        return PlanItem(step.name, "SKIP", _out(step), "missing tool: mypy")
+    return PlanItem(step.name, "RUN", _out(step), "")
+
+
+def eval_pytest(ctx: Any, step: PytestStep) -> PlanItem:
+    if ctx.options.no_pytest:
+        return PlanItem(step.name, "SKIP", _out(step), "disabled by --no-pytest")
+    if not ctx.have("pytest"):
+        return PlanItem(step.name, "SKIP", _out(step), "missing tool: pytest")
+    if (
+        not (ctx.root / "tests").exists()
+        and not (ctx.root / "sentra" / "tests").exists()
+    ):
+        return PlanItem(step.name, "SKIP", _out(step), "no tests/ directory found")
+    return PlanItem(step.name, "RUN", _out(step), "")
+
+
+def eval_rg(ctx: Any, step: Any) -> PlanItem:
+    if ctx.options.no_rg:
+        return PlanItem(step.name, "SKIP", _out(step), "disabled by --no-rg")
+    if not ctx.have("rg"):
+        return PlanItem(step.name, "SKIP", _out(step), "missing tool: rg")
+    return PlanItem(step.name, "RUN", _out(step), "")
+
+
+REGISTRY: list[tuple[type[Any], Callable[[Any, Any], PlanItem]]] = [
+    (ShellStep, eval_shell),
+    (RuffCheckStep, eval_ruff),
+    (RuffFormatCheckStep, eval_ruff),
+    (MypyStep, eval_mypy),
+    (PytestStep, eval_pytest),
+    (RipgrepScanStep, eval_rg),
+]
+
+
+def plan_for_profile(ctx: Any, profile: Any) -> list[PlanItem]:
+    items: list[PlanItem] = []
+    for step in profile.steps:
+        item: PlanItem | None = None
+
+        for cls, fn in REGISTRY:
+            if isinstance(step, cls):
+                item = fn(ctx, step)
+                break
+        if item is None:
+            item = PlanItem(step.name, "RUN", _out(step), "")
+        items.append(item)
+    return items

pybundle/manifest.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from .context import BundleContext
+
+
+def _git_commit_hash(root: Path, git_path: str | None) -> str | None:
+    """Return HEAD commit hash if root is inside a git repo, else None."""
+    if not git_path:
+        return None
+    try:
+        # If this fails, we're not in a repo or git isn't functional.
+        p = subprocess.run(
+            [git_path, "rev-parse", "HEAD"],
+            cwd=str(root),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return p.stdout.strip() or None
+    except Exception:
+        return None
+
+
+def write_manifest(
+    *,
+    ctx: BundleContext,
+    profile_name: str,
+    archive_path: Path,
+    archive_format_used: str,
+) -> None:
+    """Write a stable, machine-readable manifest for automation."""
+    git_hash = _git_commit_hash(ctx.root, ctx.tools.git)
+
+    manifest: dict[str, Any] = {
+        "schema_version": 1,
+        "tool": {"name": "pybundle"},
+        "timestamp_utc": ctx.ts,
+        "profile": profile_name,
+        "paths": {
+            "root": str(ctx.root),
+            "workdir": str(ctx.workdir),
+            "srcdir": str(ctx.srcdir),
+            "logdir": str(ctx.logdir),
+            "metadir": str(ctx.metadir),
+        },
+        "outputs": {
+            "archive": {
+                "path": str(archive_path),
+                "name": archive_path.name,
+                "format": archive_format_used,
+            },
+            "summary_json": str(ctx.summary_json),
+            "manifest_json": str(ctx.manifest_json),
+            "runlog": str(ctx.runlog),
+        },
+        "options": asdict(ctx.options),
+        "run": {
+            "strict": ctx.strict,
+            "redact": ctx.redact,
+            "spinner": ctx.spinner,
+            "keep_workdir": ctx.keep_workdir,
+            "archive_format_requested": ctx.archive_format,
+            "name_prefix": ctx.name_prefix,
+        },
+        "tools": asdict(ctx.tools),
+        "git": {"commit": git_hash},
+    }
+
+    ctx.manifest_json.write_text(
+        json.dumps(manifest, indent=2, sort_keys=True),
+        encoding="utf-8",
+    )

pybundle/packaging.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from .context import BundleContext
+
+
+def resolve_archive_format(ctx: BundleContext) -> str:
+    fmt_used = ctx.archive_format
+    if fmt_used == "auto":
+        fmt_used = "zip" if ctx.tools.zip else "tar.gz"
+    return fmt_used
+
+
+def archive_output_path(ctx: BundleContext, fmt_used: str) -> Path:
+    if fmt_used == "zip":
+        return ctx.outdir / f"{ctx.name_prefix}.zip"
+    return ctx.outdir / f"{ctx.name_prefix}.tar.gz"
+
+
+def make_archive(ctx: BundleContext) -> tuple[Path, str]:
+    fmt_used = resolve_archive_format(ctx)
+
+    if fmt_used == "zip":
+        out = archive_output_path(ctx, fmt_used)
+        # zip wants working dir above target folder
+        subprocess.run(
+            ["zip", "-qr", str(out), ctx.workdir.name],
+            cwd=str(ctx.workdir.parent),
+            check=False,
+        )
+        return out, fmt_used
+
+    out = archive_output_path(ctx, fmt_used)
+    subprocess.run(
+        ["tar", "-czf", str(out), ctx.workdir.name],
+        cwd=str(ctx.workdir.parent),
+        check=False,
+    )
+    return out, fmt_used