gwc-pybundle 2.1.2__py3-none-any.whl

pybundle/filters.py

@@ -0,0 +1,228 @@
+from fnmatch import fnmatch
+from pathlib import Path
+
+EXCLUDE_PATTERNS = {
+    "*.egg",
+    "*.egg-info",
+    "*.appimage",
+    "*.deb",
+    "*.rpm",
+    "*.exe",
+    "*.msi",
+    "*.dmg",
+    "*.pkg",
+    "*.so",
+    "*.dll",
+    "*.dylib",
+    "*.db",
+    "*.sqlite",
+    "*.sqlite3",
+    "*.zip",
+    "*.tar",
+    "*.gz",
+    "*.tgz",
+    "*.bz2",
+    "*.xz",
+    "*.7z",
+    "*.rej",
+    "*.orig",
+}
+
+DEFAULT_EXCLUDE_DIRS = {
+    ".git",
+    ".venv",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".pytest_cache",
+    "__pycache__",
+    "node_modules",
+    "dist",
+    "build",
+    "target",
+    ".next",
+    ".nuxt",
+    "artifacts",
+    ".cache",
+    ".hg",
+    ".svn",
+    "venv",
+    "env",  # Added
+    ".direnv",
+    ".pybundle-venv",
+    ".freeze-venv",  # Added - common in enterprise freeze workflows
+    "site-packages",  # Added - never scan installed packages
+    "binaries",
+    "out",
+    ".svelte-kit",
+}
+
+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",
+    "requirements-dev.txt",
+    "package.json",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "tsconfig.json",
+    "vite.config.js",
+    "vite.config.ts",
+    "webpack.config.js",
+    "webpack.config.ts",
+    "Cargo.toml",
+    "Cargo.lock",
+    "tauri.conf.json",
+    "tauri.conf.json5",
+    "tauri.conf.toml",
+]
+
+DEFAULT_INCLUDE_DIRS = [
+    "src",
+    "tests",
+    "tools",
+    "docs",
+    ".github",
+    "app",
+    "templates",
+    "static",
+    "src-tauri",
+    "frontend",
+    "web",
+    "ui",
+]
+
+DEFAULT_INCLUDE_GLOBS = [
+    "*.py",
+    "*/**/*.py",
+    "templates/**/*",
+    "static/**/*",
+]
+
+DEFAULT_EXCLUDE_FILE_EXTS: set[str] = {
+    ".appimage",
+    ".deb",
+    ".rpm",
+    ".exe",
+    ".msi",
+    ".dmg",
+    ".pkg",
+    ".so",
+    ".dll",
+    ".dylib",
+    ".db",
+    ".sqlite",
+    ".sqlite3",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".tgz",
+    ".bz2",
+    ".xz",
+    ".7z",
+    ".git",
+    ".venv",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".pytest_cache",
+    "__pycache__",
+    "node_modules",
+    "dist",
+    "build",
+    "artifacts",
+    ".cache",
+}
+
+
+def is_excluded_by_name(
+    name: str, *, exclude_names: set[str], exclude_patterns: set[str]
+) -> bool:
+    if name in exclude_names:
+        return True
+    return any(fnmatch(name, pat) for pat in exclude_patterns)
+
+
+def is_excluded_name(self, name: str) -> bool:
+    return is_excluded_by_name(
+        name, exclude_names=self.exclude_dirs, exclude_patterns=self.exclude_patterns
+    )
+
+
+def is_excluded_path(
+    rel: Path,
+    exclude_names: set[str],
+    exclude_patterns: set[str],
+) -> bool:
+    # Exclude if *any* part matches (dirs) OR the final filename matches
+    for part in rel.parts:
+        if is_excluded_by_name(
+            part, exclude_names=exclude_names, exclude_patterns=exclude_patterns
+        ):
+            return True
+    return False
+
+
+def should_exclude_from_analysis(path: Path) -> bool:
+    """Check if path should be excluded from project analysis.
+    
+    This is a comprehensive filter for ALL analysis steps to prevent
+    scanning dependencies, caches, and build artifacts.
+    
+    Use this for: type coverage, docstring coverage, link validation,
+    complexity analysis, and any other metrics that should reflect
+    PROJECT code only, not dependencies.
+    """
+    parts = set(path.parts)
+    
+    # Comprehensive list of dependency/cache/build directories
+    exclude_patterns = {
+        # Virtual environments (all common patterns)
+        ".venv", "venv", "env", ".env",
+        ".pybundle-venv", ".freeze-venv",
+        # Match any venv-like directory (e.g., .gaslog-venv)
+        # Check if any part ends with -venv or starts with venv
+    }
+    
+    # Additional checks for venv-like patterns
+    for part in parts:
+        if part.endswith("-venv") or part.endswith("_venv"):
+            return True
+        if "site-packages" in part:
+            return True
+    
+    # Standard exclusions
+    if parts & {
+        # Caches
+        ".mypy_cache", ".ruff_cache", ".pytest_cache", "__pycache__",
+        ".cache", ".tox", ".nox",
+        # Build outputs
+        "build", "dist", "target", "out", "artifacts",
+        # Version control
+        ".git", ".hg", ".svn",
+        # Dependencies
+        "node_modules",
+        # Other
+        "binaries",
+    }:
+        return True
+    
+    return False

pybundle/manifest.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+import subprocess  # nosec B404 - Required for git operations, paths validated
+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(  # nosec B603
+            [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,
+            "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,45 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for archive creation, paths validated
+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":
+        if not ctx.tools.zip:
+            raise RuntimeError("zip tool not available")
+        out = archive_output_path(ctx, fmt_used)
+        # zip wants working dir above target folder
+        subprocess.run(  # nosec B603
+            [ctx.tools.zip, "-qr", str(out), ctx.workdir.name],
+            cwd=str(ctx.workdir.parent),
+            check=False,
+        )
+        return out, fmt_used
+
+    if not ctx.tools.tar:
+        raise RuntimeError("tar tool not available")
+    out = archive_output_path(ctx, fmt_used)
+    subprocess.run(  # nosec B603
+        [ctx.tools.tar, "-czf", str(out), ctx.workdir.name],
+        cwd=str(ctx.workdir.parent),
+        check=False,
+    )
+    return out, fmt_used

pybundle/policy.py

@@ -0,0 +1,132 @@
+# pybundle/policy.py
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from pybundle.filters import (
+    DEFAULT_EXCLUDE_DIRS,
+    DEFAULT_EXCLUDE_FILE_EXTS,
+    DEFAULT_INCLUDE_FILES,
+    DEFAULT_INCLUDE_DIRS,
+    DEFAULT_INCLUDE_GLOBS,
+    EXCLUDE_PATTERNS,
+    is_excluded_by_name,
+)
+
+
+@dataclass(frozen=True)
+class AIContextPolicy:
+    exclude_dirs: set[str] = field(default_factory=lambda: set(DEFAULT_EXCLUDE_DIRS))
+    exclude_patterns: set[str] = field(default_factory=lambda: set(EXCLUDE_PATTERNS))
+    exclude_file_exts: set[str] = field(
+        default_factory=lambda: set(DEFAULT_EXCLUDE_FILE_EXTS)
+    )
+
+    include_files: list[str] = field(
+        default_factory=lambda: list(DEFAULT_INCLUDE_FILES)
+    )
+    include_dirs: list[str] = field(default_factory=lambda: list(DEFAULT_INCLUDE_DIRS))
+    include_globs: list[str] = field(
+        default_factory=lambda: list(DEFAULT_INCLUDE_GLOBS)
+    )
+
+    # AI-friendly knobs
+    tree_max_depth: int = 4
+    largest_limit: int = 80
+    roadmap_max_files: int = 20000
+    roadmap_mermaid_depth: int = 2
+    roadmap_mermaid_max_edges: int = 180
+
+    def include_dir_candidates(self, root: Path) -> list[Path]:
+        out: list[Path] = []
+        for d in self.include_dirs:
+            p = root / d
+            if p.exists():
+                out.append(p)
+        return out or [root]
+
+
+@dataclass
+class PathFilter:
+    """
+    Shared filtering logic across steps:
+    - prune excluded dir names
+    - prune venvs by structure (any name)
+    - optionally exclude noisy file types by extension
+    """
+
+    exclude_dirs: set[str]
+    exclude_file_exts: set[str]
+    exclude_patterns: set[str] = field(default_factory=set)
+    detect_venvs: bool = True
+
+    def is_venv_root(self, p: Path) -> bool:
+        if not p.is_dir():
+            return False
+
+        if (p / "pyvenv.cfg").is_file():
+            return True
+
+        if (p / "bin").is_dir():
+            if (p / "bin" / "activate").is_file() and (
+                (p / "bin" / "python").exists() or (p / "bin" / "python3").exists()
+            ):
+                return True
+            if any((p / "lib").glob("python*/site-packages")):
+                return True
+
+        if (p / "Scripts").is_dir():
+            if (p / "Scripts" / "activate").is_file() and (
+                (p / "Scripts" / "python.exe").is_file()
+                or (p / "Scripts" / "python").exists()
+            ):
+                return True
+            if (p / "Lib" / "site-packages").is_dir():
+                return True
+
+        if (p / ".Python").exists():
+            return True
+
+        return False
+
+    def should_prune_dir(self, parent_dir: Path, child_name: str) -> bool:
+        if is_excluded_by_name(
+            child_name,
+            exclude_names=self.exclude_dirs,
+            exclude_patterns=self.exclude_patterns,
+        ):
+            return True
+        if self.detect_venvs and self.is_venv_root(parent_dir / child_name):
+            return True
+        return False
+
+    def should_include_file(self, root: Path, p: Path) -> bool:
+        try:
+            rel = p.relative_to(root)
+        except Exception:
+            return False
+
+        # reject files under excluded dirs by name/pattern
+        for part in rel.parts[:-1]:
+            if is_excluded_by_name(
+                part,
+                exclude_names=self.exclude_dirs,
+                exclude_patterns=self.exclude_patterns,
+            ):
+                return False
+
+        # reject excluded file names by pattern (e.g. *.egg, *.rej)
+        if is_excluded_by_name(
+            rel.name,
+            exclude_names=self.exclude_dirs,
+            exclude_patterns=self.exclude_patterns,
+        ):
+            return False
+
+        # reject excluded extensions
+        ext = p.suffix.lower()
+        if ext in self.exclude_file_exts:
+            return False
+
+        return True