contextzip 0.2.2__tar.gz → 0.2.4__tar.gz

{contextzip-0.2.2 → contextzip-0.2.4}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: contextzip
-Version: 0.2.2
+Version: 0.2.4
 Summary: Intelligently package your codebase for AI tools
 Author-email: Deepesh <akadeepesh@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/akadeepesh/contextzip
 Project-URL: Repository, https://github.com/akadeepesh/contextzip
 Project-URL: Issues, https://github.com/akadeepesh/contextzip/issues
-Keywords: ai,cli,developer-tools,context,zip,llm
+Keywords: ai,cli,developer-tools,context,zip,llm,claude,chatgpt,code-packaging
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{contextzip-0.2.2 → contextzip-0.2.4}/contextzip/__init__.py

@@ -1,3 +1,3 @@
 """contextzip — intelligent codebase packager for AI tools."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{contextzip-0.2.2 → contextzip-0.2.4}/contextzip/cli.py

@@ -74,7 +74,7 @@ def _modifier_options(f):
         click.option(
             "--output", "-o",
             default=None, metavar="FILE",
-            help="Output ZIP path. Defaults to <project>_context_<timestamp>.zip in temp dir.",
+            help="Output ZIP path. Bypasses .contextzip/ workspace — writes directly to FILE.",
         ),
         click.option(
             "--no-clipboard",
@@ -431,6 +431,7 @@ def _run(
             project_dir=project_dir,
             output_path=output_path,
             console=console,
+            git_changes=git_changes,
         )
     except Exception as exc:
         console.print(f"\n[red]Failed to create ZIP:[/] {exc}")

{contextzip-0.2.2 → contextzip-0.2.4}/contextzip/detector.py

@@ -120,7 +120,7 @@ _RULES: list[_Rule] = [
     # ── Ruby ─────────────────────────────────────────────────────────────
     _Rule(
         name="Ruby",
-        module="base",  # no dedicated rule module yet; base covers it
+        module="ruby",
         check=lambda p: _file_exists(p, "Gemfile"),
         weight=2,
     ),
@@ -215,4 +215,4 @@ def _dep_present_py(project_dir: Path, dep: str) -> bool:
         except Exception:
             pass
 
-    return False
+    return False

{contextzip-0.2.2 → contextzip-0.2.4}/contextzip/filters.py

@@ -35,6 +35,7 @@ _RULE_REGISTRY: dict[str, str] = {
     "python": "contextzip.rules.python",
     "rust":   "contextzip.rules.rust",
     "go":     "contextzip.rules.go",
+    "ruby":   "contextzip.rules.ruby",
 }
 
 # Files larger than this trigger a warning (but are still included)
@@ -184,10 +185,10 @@ def resolve_files_from_git(
     Build a :class:`ResolveResult` from a pre-selected list of files reported
     by git (modified, added, untracked).
 
-    Unlike :func:`resolve_files`, this function does **not** apply exclusion
-    specs — the caller has already determined which files to include via
-    ``git status``.  Size and binary checks are still performed so that the
-    usual warnings appear in the CLI output.
+    Applies the base exclusion spec as a safety floor even though git selected
+    the files — a git-tracked ``.env`` or secret key file must still be blocked.
+    Size and binary checks are also performed so that the usual warnings appear
+    in the CLI output.
 
     Parameters
     ----------
@@ -197,6 +198,10 @@ def resolve_files_from_git(
     project_dir:
         Absolute path to the project root (used for relative-path guards).
     """
+    # Build the base spec once — this is our safety floor regardless of what
+    # git reports as changed. It blocks .env, secrets, binaries, etc.
+    base_spec = build_spec(rule_modules=["base"])
+
     result = ResolveResult()
 
     for abs_path in sorted(git_files):
@@ -217,11 +222,17 @@ def resolve_files_from_git(
 
         # ── Guard: must be under project_dir ────────────────────────────────
         try:
-            abs_path.relative_to(project_dir)
+            rel = abs_path.relative_to(project_dir)
         except ValueError:
             result.skipped.append((abs_path, "outside project tree"))
             continue
 
+        # ── Base safety floor — block secrets / binaries even if git-tracked ─
+        rel_str = rel.as_posix()
+        if _any_parent_excluded(rel, base_spec) or base_spec.match_file(rel_str):
+            result.excluded.append(abs_path)
+            continue
+
         # ── Readability / stat check ─────────────────────────────────────────
         try:
             file_size = abs_path.stat().st_size
@@ -293,4 +304,4 @@ def _is_binary(path: Path) -> bool:
             chunk = fh.read(_BINARY_PEEK)
         return b"\x00" in chunk
     except OSError:
-        return False
+        return False

contextzip-0.2.4/contextzip/packager.py

@@ -0,0 +1,275 @@
+"""
+packager.py — Creates the ZIP archive from a ResolveResult.
+
+Phase 5 changes:
+  - Accepts ResolveResult instead of a bare list[Path]
+  - Reports skipped (unreadable / symlink) files to the caller
+  - Caps individual file read to avoid runaway memory on huge files
+  - Carries skipped_paths forward into PackageResult for CLI display
+
+Phase 6 changes:
+  - Introduces .contextzip/ workspace directory at the git root (or CWD fallback)
+  - Auto-creates .contextzip/ and registers it in .gitignore when inside a git repo
+  - Deterministic output names: codebase.zip (default) or changes.zip (--git-changes)
+  - --output flag bypasses workspace logic entirely (user owns the path)
+"""
+
+from __future__ import annotations
+
+import tempfile
+import zipfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    FileSizeColumn,
+    Progress,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    TransferSpeedColumn,
+)
+
+from contextzip.filters import ResolveResult
+
+# The entry written into .gitignore
+_GITIGNORE_ENTRY = ".contextzip/"
+
+
+# ---------------------------------------------------------------------------
+# Result model
+# ---------------------------------------------------------------------------
+
+@dataclass
+class PackageResult:
+    zip_path:            Path
+    file_count:          int
+    uncompressed_bytes:  int
+    compressed_bytes:    int
+    skipped_in_zip:      list[tuple[Path, str]] = field(default_factory=list)
+
+    @property
+    def compression_ratio(self) -> float:
+        if self.uncompressed_bytes == 0:
+            return 0.0
+        return max(0.0, 1.0 - (self.compressed_bytes / self.uncompressed_bytes))
+
+    @property
+    def compression_pct(self) -> str:
+        return f"{self.compression_ratio * 100:.0f}%"
+
+    @property
+    def grew(self) -> bool:
+        return self.compressed_bytes > self.uncompressed_bytes
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def create_zip(
+    resolve_result: ResolveResult,
+    project_dir: Path,
+    output_path: Path | None,
+    console: Console,
+    git_changes: bool = False,
+) -> PackageResult:
+    """
+    Write the included files from *resolve_result* into a ZIP archive.
+
+    If *output_path* is given (via --output) it is used as-is and the
+    .contextzip/ workspace logic is skipped entirely.
+
+    Otherwise the archive is written to the .contextzip/ workspace
+    directory (created automatically) at the git root, or the CWD if
+    no git repository is detected.
+
+    Returns a :class:`PackageResult` with compression stats and any
+    files that had to be skipped during writing (e.g. permission denied).
+    """
+    if output_path is not None:
+        # User specified --output: honour it exactly, no workspace logic.
+        zip_path = output_path
+    else:
+        zip_path = _workspace_output_path(project_dir, git_changes, console)
+
+    zip_path.parent.mkdir(parents=True, exist_ok=True)
+
+    included: list[Path] = resolve_result.included
+    skipped_in_zip: list[tuple[Path, str]] = []
+    uncompressed = 0
+    file_count = 0
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[cyan]{task.description}[/]"),
+        BarColumn(),
+        TaskProgressColumn(),
+        FileSizeColumn(),
+        TransferSpeedColumn(),
+        TimeElapsedColumn(),
+        console=console,
+        transient=True,
+    ) as progress:
+
+        total_bytes = sum(
+            p.stat().st_size for p in included if p.is_file()
+        )
+        task = progress.add_task("Compressing…", total=max(total_bytes, 1))
+
+        with zipfile.ZipFile(
+            zip_path, "w",
+            compression=zipfile.ZIP_DEFLATED,
+            compresslevel=6,
+        ) as zf:
+            for abs_path in included:
+                if not abs_path.is_file():
+                    continue
+
+                try:
+                    rel = abs_path.relative_to(project_dir)
+                except ValueError:
+                    skipped_in_zip.append((abs_path, "outside project tree"))
+                    continue
+
+                try:
+                    file_size = abs_path.stat().st_size
+                except OSError as e:
+                    skipped_in_zip.append((abs_path, f"stat failed: {e}"))
+                    continue
+
+                try:
+                    zf.write(abs_path, arcname=rel.as_posix())
+                    uncompressed += file_size
+                    file_count += 1
+                except PermissionError:
+                    skipped_in_zip.append((abs_path, "permission denied"))
+                except OSError as e:
+                    skipped_in_zip.append((abs_path, str(e)))
+                finally:
+                    progress.advance(task, file_size)
+
+    compressed = zip_path.stat().st_size
+
+    return PackageResult(
+        zip_path=zip_path,
+        file_count=file_count,
+        uncompressed_bytes=uncompressed,
+        compressed_bytes=compressed,
+        skipped_in_zip=skipped_in_zip,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Workspace helpers
+# ---------------------------------------------------------------------------
+
+def _find_git_root(start: Path) -> Path | None:
+    """
+    Walk up the directory tree from *start* looking for a .git directory.
+    Returns the directory that contains .git, or None if not found.
+    """
+    current = start.resolve()
+    while True:
+        if (current / ".git").is_dir():
+            return current
+        parent = current.parent
+        if parent == current:
+            # Reached filesystem root without finding .git
+            return None
+        current = parent
+
+
+def _ensure_gitignore(git_root: Path) -> None:
+    """
+    Ensure .contextzip/ is listed in <git_root>/.gitignore.
+
+    - If .gitignore exists and already contains the entry: do nothing.
+    - If .gitignore exists but lacks the entry: append it.
+    - If .gitignore does not exist: create it with just the entry.
+    """
+    gitignore_path = git_root / ".gitignore"
+
+    if gitignore_path.is_file():
+        content = gitignore_path.read_text(encoding="utf-8", errors="replace")
+        # Check for the entry on its own line (with or without trailing slash variants)
+        lines = [line.strip() for line in content.splitlines()]
+        if _GITIGNORE_ENTRY in lines or _GITIGNORE_ENTRY.rstrip("/") in lines:
+            return  # Already present — nothing to do
+        # Append, ensuring there's a trailing newline before our entry
+        separator = "\n" if content and not content.endswith("\n") else ""
+        with gitignore_path.open("a", encoding="utf-8") as f:
+            f.write(f"{separator}\n# contextzip workspace\n{_GITIGNORE_ENTRY}\n")
+    else:
+        # .gitignore doesn't exist — create a minimal one
+        gitignore_path.write_text(
+            f"# contextzip workspace\n{_GITIGNORE_ENTRY}\n",
+            encoding="utf-8",
+        )
+
+
+def _workspace_dir(project_dir: Path) -> tuple[Path, bool]:
+    """
+    Resolve the .contextzip/ workspace directory.
+
+    Returns ``(workspace_path, is_git_repo)`` where:
+    - workspace_path is <git_root>/.contextzip/ when inside a git repo
+    - workspace_path is <project_dir>/.contextzip/ as a fallback
+    - is_git_repo indicates whether a git root was found
+    """
+    git_root = _find_git_root(project_dir)
+    if git_root is not None:
+        return git_root / ".contextzip", True
+    return project_dir / ".contextzip", False
+
+
+def _workspace_output_path(
+    project_dir: Path,
+    git_changes: bool,
+    console: Console,
+) -> Path:
+    """
+    Determine the output ZIP path inside the .contextzip/ workspace.
+
+    Side effects:
+    - Creates the workspace directory if it doesn't exist.
+    - Manages .gitignore registration when inside a git repo.
+    - Falls back to the system temp directory if the workspace cannot
+      be created (e.g. read-only filesystem), printing a warning.
+    """
+    workspace, is_git_repo = _workspace_dir(project_dir)
+    filename = "changes.zip" if git_changes else "codebase.zip"
+
+    # Attempt to create the workspace directory
+    try:
+        workspace.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        # Graceful fallback: warn and use temp dir
+        console.print(
+            f"\n  [yellow]⚠[/]  Could not create [cyan].contextzip/[/] workspace "
+            f"([dim]{exc}[/]) — falling back to temp directory.\n"
+        )
+        return Path(tempfile.gettempdir()) / filename
+
+    # Handle .gitignore only when we're inside a git repo
+    if is_git_repo:
+        git_root = workspace.parent  # workspace is <git_root>/.contextzip
+        try:
+            _ensure_gitignore(git_root)
+        except OSError:
+            # Non-fatal: gitignore update failed, carry on silently
+            pass
+
+    return workspace / filename
+
+
+# ---------------------------------------------------------------------------
+# Legacy helper (kept for any internal callers that may reference it)
+# ---------------------------------------------------------------------------
+
+def _safe_name(name: str) -> str:
+    safe = "".join(c if c.isalnum() or c in "-_." else "_" for c in name)
+    return safe[:48] or "project"

{contextzip-0.2.2 → contextzip-0.2.4}/contextzip/rules/base.py

@@ -5,7 +5,6 @@ Universal exclusion rules applied to every project regardless of language.
 PATTERNS = [
     # Version control
     ".git/",
-    ".gitignore",
     ".svn/",
     ".hg/",
 
@@ -62,6 +61,20 @@ PATTERNS = [
     "*.gz",
     "*.rar",
 
-    # The output zip itself (avoid recursion)
-    "*_context_*.zip",
-]
+    # contextzip workspace directory — always excluded regardless of .gitignore state
+    ".contextzip/",
+
+    # GitHub / repo governance (not useful as AI context)
+    "CHANGELOG.md",
+    "CHANGELOG",
+    "CONTRIBUTING.md",
+    "CONTRIBUTING",
+    "LICENSE",
+    "LICENSE.md",
+    "LICENSE.txt",
+    "SECURITY.md",
+    "CODE_OF_CONDUCT.md",
+    ".github/ISSUE_TEMPLATE/",
+    ".github/PULL_REQUEST_TEMPLATE.md",
+    ".github/PULL_REQUEST_TEMPLATE/",
+]

contextzip-0.2.4/contextzip/rules/ruby.py

@@ -0,0 +1,41 @@
+"""
+Ruby / Rails / Bundler exclusion rules.
+"""
+
+PATTERNS = [
+    # Bundler
+    "vendor/bundle/",
+    ".bundle/",
+    "Gemfile.lock",
+
+    # Ruby version managers
+    ".ruby-version",
+    ".ruby-gemset",
+    ".rvmrc",
+
+    # Built gems
+    "*.gem",
+    "pkg/",
+
+    # Rails-specific
+    "tmp/",           # runtime temp (also in base, fine to repeat)
+    "log/",           # request logs (also in base)
+    "public/assets/", # precompiled assets (sprockets / propshaft)
+    "public/packs/",  # webpacker output
+    "storage/",       # ActiveStorage blobs
+    ".byebug_history",
+
+    # Test coverage
+    "coverage/",
+
+    # Documentation
+    "doc/",
+    "rdoc/",
+
+    # Spring (Rails app preloader)
+    ".spring/",
+
+    # Compiled C extensions
+    "*.bundle",
+    "*.so",           # also in base, explicit here for clarity
+]

{contextzip-0.2.2 → contextzip-0.2.4}/contextzip.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: contextzip
-Version: 0.2.2
+Version: 0.2.4
 Summary: Intelligently package your codebase for AI tools
 Author-email: Deepesh <akadeepesh@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/akadeepesh/contextzip
 Project-URL: Repository, https://github.com/akadeepesh/contextzip
 Project-URL: Issues, https://github.com/akadeepesh/contextzip/issues
-Keywords: ai,cli,developer-tools,context,zip,llm
+Keywords: ai,cli,developer-tools,context,zip,llm,claude,chatgpt,code-packaging
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{contextzip-0.2.2 → contextzip-0.2.4}/contextzip.egg-info/SOURCES.txt

@@ -19,4 +19,5 @@ contextzip/rules/base.py
 contextzip/rules/go.py
 contextzip/rules/node.py
 contextzip/rules/python.py
+contextzip/rules/ruby.py
 contextzip/rules/rust.py

{contextzip-0.2.2 → contextzip-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "contextzip"
-version = "0.2.2"
+version = "0.2.4"
 description = "Intelligently package your codebase for AI tools"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -13,7 +13,7 @@ license-files = ["LICENSE"]
 authors = [
     { name = "Deepesh", email = "akadeepesh@gmail.com" }
 ]
-keywords = ["ai", "cli", "developer-tools", "context", "zip", "llm"]
+keywords = ["ai", "cli", "developer-tools", "context", "zip", "llm", "claude", "chatgpt", "code-packaging"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Environment :: Console",

contextzip-0.2.2/contextzip/packager.py

@@ -1,152 +0,0 @@
-"""
-packager.py — Creates the ZIP archive from a ResolveResult.
-
-Phase 5 changes:
-  - Accepts ResolveResult instead of a bare list[Path]
-  - Reports skipped (unreadable / symlink) files to the caller
-  - Caps individual file read to avoid runaway memory on huge files
-  - Carries skipped_paths forward into PackageResult for CLI display
-"""
-
-from __future__ import annotations
-
-import tempfile
-import zipfile
-from dataclasses import dataclass, field
-from datetime import datetime
-from pathlib import Path
-
-from rich.console import Console
-from rich.progress import (
-    BarColumn,
-    FileSizeColumn,
-    Progress,
-    SpinnerColumn,
-    TaskProgressColumn,
-    TextColumn,
-    TimeElapsedColumn,
-    TransferSpeedColumn,
-)
-
-from contextzip.filters import ResolveResult
-
-
-# ---------------------------------------------------------------------------
-# Result model
-# ---------------------------------------------------------------------------
-
-@dataclass
-class PackageResult:
-    zip_path:            Path
-    file_count:          int
-    uncompressed_bytes:  int
-    compressed_bytes:    int
-    skipped_in_zip:      list[tuple[Path, str]] = field(default_factory=list)
-
-    @property
-    def compression_ratio(self) -> float:
-        if self.uncompressed_bytes == 0:
-            return 0.0
-        return max(0.0, 1.0 - (self.compressed_bytes / self.uncompressed_bytes))
-
-    @property
-    def compression_pct(self) -> str:
-        return f"{self.compression_ratio * 100:.0f}%"
-
-    @property
-    def grew(self) -> bool:
-        return self.compressed_bytes > self.uncompressed_bytes
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-def create_zip(
-    resolve_result: ResolveResult,
-    project_dir: Path,
-    output_path: Path | None,
-    console: Console,
-) -> PackageResult:
-    """
-    Write the included files from *resolve_result* into a ZIP archive.
-    Returns a :class:`PackageResult` with compression stats and any
-    files that had to be skipped during writing (e.g. permission denied).
-    """
-    zip_path = output_path or _auto_output_path(project_dir)
-    zip_path.parent.mkdir(parents=True, exist_ok=True)
-
-    included      = resolve_result.included
-    skipped_in_zip: list[tuple[Path, str]] = []
-    uncompressed  = 0
-    file_count    = 0
-
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[cyan]{task.description}[/]"),
-        BarColumn(),
-        TaskProgressColumn(),
-        FileSizeColumn(),
-        TransferSpeedColumn(),
-        TimeElapsedColumn(),
-        console=console,
-        transient=True,
-    ) as progress:
-
-        total_bytes = sum(
-            p.stat().st_size for p in included if p.is_file()
-        )
-        task = progress.add_task("Compressing…", total=max(total_bytes, 1))
-
-        with zipfile.ZipFile(
-            zip_path, "w",
-            compression=zipfile.ZIP_DEFLATED,
-            compresslevel=6,
-        ) as zf:
-            for abs_path in included:
-                if not abs_path.is_file():
-                    continue
-
-                try:
-                    rel = abs_path.relative_to(project_dir)
-                except ValueError:
-                    skipped_in_zip.append((abs_path, "outside project tree"))
-                    continue
-
-                try:
-                    file_size = abs_path.stat().st_size
-                    zf.write(abs_path, arcname=rel.as_posix())
-                    uncompressed += file_size
-                    file_count   += 1
-                except PermissionError:
-                    skipped_in_zip.append((abs_path, "permission denied"))
-                except OSError as e:
-                    skipped_in_zip.append((abs_path, str(e)))
-                finally:
-                    progress.advance(task, abs_path.stat().st_size if abs_path.exists() else 0)
-
-    compressed = zip_path.stat().st_size
-
-    return PackageResult(
-        zip_path=zip_path,
-        file_count=file_count,
-        uncompressed_bytes=uncompressed,
-        compressed_bytes=compressed,
-        skipped_in_zip=skipped_in_zip,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def _auto_output_path(project_dir: Path) -> Path:
-    project_name = _safe_name(project_dir.name)
-    timestamp    = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename     = f"{project_name}_context_{timestamp}.zip"
-    return Path(tempfile.gettempdir()) / filename
-
-
-def _safe_name(name: str) -> str:
-    safe = "".join(c if c.isalnum() or c in "-_." else "_" for c in name)
-    return safe[:48] or "project"