contextzip 0.3.8__tar.gz → 0.4.0__tar.gz

contextzip-0.4.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: contextzip
+Version: 0.4.0
+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,claude,chatgpt,code-packaging
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Requires-Dist: rich>=13.0
+Requires-Dist: pathspec>=0.12
+Requires-Dist: httpx>=0.27
+Dynamic: license-file
+
+# contextzip
+
+> Package exactly the right parts of your codebase and paste it into any AI tool — in one command.
+
+```bash
+pip install contextzip
+```
+
+**📖 Full docs, every flag, every config option: [contextzip.vercel.app](https://contextzip.vercel.app)**
+
+---
+
+## Why contextzip
+
+Every AI session starts the same way: hunt down the relevant files, skip `node_modules` and build artifacts by hand, zip it, find the zip, upload it — then do it all again next session.
+
+contextzip eliminates that. Run it from your project root — it detects your stack, applies smart exclusions, and produces a lean ZIP ready to paste into Claude, ChatGPT, or any AI tool. When the AI hands changes back, `contextzip apply-zip` writes them into your project safely.
+
+## Quick start
+
+```bash
+cd ~/projects/my-app
+contextzip
+```
+
+That's it — no flags required. contextzip detects your framework, excludes the noise, and writes a ZIP to `.contextzip/`.
+
+## The essentials
+
+| Command | What it does |
+|---|---|
+| `contextzip` | Detect stack, exclude noise, package the project |
+| `contextzip --prompt "task"` | Let Gemini pick only the files relevant to a task |
+| `contextzip --git-changes` | Package only modified/staged/untracked files |
+| `contextzip apply-zip` | Write an AI-returned ZIP back into your project, safely |
+| `contextzip watch -- npm run dev` | Auto-package debug context the moment an error appears |
+| `contextzip config --ui` | Set include/exclude rules visually in a local browser tab |
+
+Every command supports `--dry-run`, `--verbose`, `--include`, `--exclude`, and more — see the [full CLI reference](https://contextzip.vercel.app/cli).
+
+contextzip respects your `.gitignore`, detects Node.js, Next.js, Python, Django, FastAPI, Rust, Go, and Ruby (including in monorepos), and never packages secrets — SSH keys, cloud credentials, and Terraform state are always excluded. Details: [contextzip.vercel.app/features](https://contextzip.vercel.app/features).
+
+## Also a Python library
+
+```python
+from contextzip import get_git_changes, create_zip
+
+collection = get_git_changes()
+pkg = create_zip(collection, output="/tmp/changes.zip")
+```
+
+Full function reference: [contextzip.vercel.app/cli#python-api](https://contextzip.vercel.app/cli#python-api)
+
+## Learn more
+
+- [Packaging & detection](https://contextzip.vercel.app/features) — frameworks, exclusion rules, safety
+- [AI-powered file selection](https://contextzip.vercel.app/ai-selection) — `--prompt`, Gemini setup
+- [Terminal error watcher](https://contextzip.vercel.app/watch) — `contextzip watch`
+- [Applying changes back](https://contextzip.vercel.app/apply-zip) — `apply-zip`, backups, safety
+- [Configuration](https://contextzip.vercel.app/configuration) — personal & project config, visual config UI
+- [CLI & Python API reference](https://contextzip.vercel.app/cli)
+
+## Contributing
+
+Contributions are welcome — especially new framework rule sets and edge-case fixes. See [CONTRIBUTING.md](https://github.com/akadeepesh/contextzip/blob/main/CONTRIBUTING.md). Please open an issue before starting a large PR.
+
+## License
+
+MIT — see [LICENSE](https://github.com/akadeepesh/contextzip/blob/main/LICENSE) for details.

contextzip-0.4.0/README.md

@@ -0,0 +1,69 @@
+# contextzip
+
+> Package exactly the right parts of your codebase and paste it into any AI tool — in one command.
+
+```bash
+pip install contextzip
+```
+
+**📖 Full docs, every flag, every config option: [contextzip.vercel.app](https://contextzip.vercel.app)**
+
+---
+
+## Why contextzip
+
+Every AI session starts the same way: hunt down the relevant files, skip `node_modules` and build artifacts by hand, zip it, find the zip, upload it — then do it all again next session.
+
+contextzip eliminates that. Run it from your project root — it detects your stack, applies smart exclusions, and produces a lean ZIP ready to paste into Claude, ChatGPT, or any AI tool. When the AI hands changes back, `contextzip apply-zip` writes them into your project safely.
+
+## Quick start
+
+```bash
+cd ~/projects/my-app
+contextzip
+```
+
+That's it — no flags required. contextzip detects your framework, excludes the noise, and writes a ZIP to `.contextzip/`.
+
+## The essentials
+
+| Command | What it does |
+|---|---|
+| `contextzip` | Detect stack, exclude noise, package the project |
+| `contextzip --prompt "task"` | Let Gemini pick only the files relevant to a task |
+| `contextzip --git-changes` | Package only modified/staged/untracked files |
+| `contextzip apply-zip` | Write an AI-returned ZIP back into your project, safely |
+| `contextzip watch -- npm run dev` | Auto-package debug context the moment an error appears |
+| `contextzip config --ui` | Set include/exclude rules visually in a local browser tab |
+
+Every command supports `--dry-run`, `--verbose`, `--include`, `--exclude`, and more — see the [full CLI reference](https://contextzip.vercel.app/cli).
+
+contextzip respects your `.gitignore`, detects Node.js, Next.js, Python, Django, FastAPI, Rust, Go, and Ruby (including in monorepos), and never packages secrets — SSH keys, cloud credentials, and Terraform state are always excluded. Details: [contextzip.vercel.app/features](https://contextzip.vercel.app/features).
+
+## Also a Python library
+
+```python
+from contextzip import get_git_changes, create_zip
+
+collection = get_git_changes()
+pkg = create_zip(collection, output="/tmp/changes.zip")
+```
+
+Full function reference: [contextzip.vercel.app/cli#python-api](https://contextzip.vercel.app/cli#python-api)
+
+## Learn more
+
+- [Packaging & detection](https://contextzip.vercel.app/features) — frameworks, exclusion rules, safety
+- [AI-powered file selection](https://contextzip.vercel.app/ai-selection) — `--prompt`, Gemini setup
+- [Terminal error watcher](https://contextzip.vercel.app/watch) — `contextzip watch`
+- [Applying changes back](https://contextzip.vercel.app/apply-zip) — `apply-zip`, backups, safety
+- [Configuration](https://contextzip.vercel.app/configuration) — personal & project config, visual config UI
+- [CLI & Python API reference](https://contextzip.vercel.app/cli)
+
+## Contributing
+
+Contributions are welcome — especially new framework rule sets and edge-case fixes. See [CONTRIBUTING.md](https://github.com/akadeepesh/contextzip/blob/main/CONTRIBUTING.md). Please open an issue before starting a large PR.
+
+## License
+
+MIT — see [LICENSE](https://github.com/akadeepesh/contextzip/blob/main/LICENSE) for details.

{contextzip-0.3.8 → contextzip-0.4.0}/contextzip/__init__.py

@@ -1,6 +1,6 @@
 """contextzip — intelligent codebase packager for AI tools."""
 
-__version__ = "0.3.8"
+__version__ = "0.4.0"
 
 from contextzip.api import (
     FileCollection,

{contextzip-0.3.8 → contextzip-0.4.0}/contextzip/ai/selector.py

@@ -33,6 +33,7 @@ def ai_select(
     ecosystem: str,
     api_key: str,
     max_files: int | None = None,
+    prompt_template: str = "",
 ) -> tuple[list[Path], str, str]:
     """
     Select the minimum relevant files for *prompt* from *resolved.included*.
@@ -41,6 +42,10 @@ def ai_select(
     project's `ai.max_files` preference (.contextzip/config.json). None
     falls back to each backend's own built-in default cap.
 
+    *prompt_template*, if non-empty, is a project's `ai.prompt_template`
+    preference — house conventions prepended to the generated prompt.txt
+    ahead of the task description.
+
     Returns
     -------
     (selected_paths, prompt_txt, method)
@@ -78,14 +83,20 @@ def ai_select(
     }
     selected_paths = [rel_to_abs[rel] for rel in selected_rel if rel in rel_to_abs]
 
-    prompt_txt = _build_prompt_txt(prompt, selected_rel, ecosystem, method)
+    prompt_txt = _build_prompt_txt(
+        prompt, selected_rel, ecosystem, method, prompt_template=prompt_template
+    )
 
     return selected_paths, prompt_txt, method
 
 
-def build_prompt_only_txt(prompt: str, ecosystem: str) -> str:
+def build_prompt_only_txt(
+    prompt: str, ecosystem: str, prompt_template: str = ""
+) -> str:
     """Build a minimal prompt.txt when no AI selection was performed."""
-    return _build_prompt_txt(prompt, [], ecosystem, USED_GEMINI)
+    return _build_prompt_txt(
+        prompt, [], ecosystem, USED_GEMINI, prompt_template=prompt_template
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -125,12 +136,14 @@ def _build_prompt_txt(
     selected_rel: list[str],
     ecosystem: str,
     method: str,
+    prompt_template: str = "",
 ) -> str:
     """
     Build the prompt.txt to include inside the ZIP.
 
-    Any AI tool that receives the ZIP immediately sees the task description,
-    the framework, and exactly which files were selected and why.
+    Any AI tool that receives the ZIP immediately sees the project's own
+    conventions (if any are configured), the task description, the
+    framework, and exactly which files were selected and why.
     """
 
     selector_label = (
@@ -139,12 +152,21 @@ def _build_prompt_txt(
         else "contextzip (keyword heuristic — Gemini was rate limited)"
     )
 
-    lines: list[str] = [
-        f"Task: {prompt}",
-        "",
-        f"Framework: {ecosystem}",
-        "",
-    ]
+    lines: list[str] = []
+
+    if prompt_template:
+        lines.append("Project conventions:")
+        lines.append(prompt_template)
+        lines.append("")
+
+    lines.extend(
+        [
+            f"Task: {prompt}",
+            "",
+            f"Framework: {ecosystem}",
+            "",
+        ]
+    )
 
     if selected_rel:
         lines.append(f"Files selected by {selector_label}:")

{contextzip-0.3.8 → contextzip-0.4.0}/contextzip/api.py

@@ -47,7 +47,7 @@ from contextzip.filters import (
     resolve_files,
     resolve_files_from_git,
 )
-from contextzip.git import GitChanges, GitError, GitErrorKind, get_changed_files
+from contextzip.git import GitError, GitErrorKind, get_changed_files
 from contextzip.packager import PackageResult, create_zip_silent
 
 

{contextzip-0.3.8 → contextzip-0.4.0}/contextzip/applier.py

@@ -112,6 +112,9 @@ class ApplyPlan:
     manifest_path: Path | None
     entries: list[ApplyEntry] = field(default_factory=list)
     extraction_dir: Path = None  # type: ignore[assignment]
+    wrapper_stripped: str | None = None
+    wrapper_note: str | None = None
+    structure_warning: str | None = None
 
     @property
     def has_manifest(self) -> bool:
@@ -133,7 +136,11 @@ class ApplyPlan:
     @property
     def is_risky(self) -> bool:
         """True if anything here warrants a confirmation prompt before writing."""
-        return bool(self.risky_entries) or not self.has_manifest
+        return (
+            bool(self.risky_entries)
+            or not self.has_manifest
+            or bool(self.structure_warning)
+        )
 
 
 @dataclass
@@ -316,20 +323,36 @@ def _is_within(path: Path, parent: Path) -> bool:
         return False
 
 
-def _safe_extract(zip_path: Path, dest: Path) -> None:
+def _safe_extract(zip_path: Path, dest: Path, strip_prefix: str | None = None) -> None:
     """
     Extract *zip_path* into *dest*, refusing to write anything if any entry
     would resolve outside *dest* (zip-slip protection). Validated in a full
     first pass before any file is written, so a malicious entry never
     causes a partial extraction.
+
+    If *strip_prefix* is given (see `_detect_common_wrapper`), that leading
+    path component is removed from every entry before it's resolved against
+    *dest* — e.g. `codebase/contextzip/config.py` extracts to
+    `contextzip/config.py` instead of recreating a `codebase/` folder.
     """
     dest = dest.resolve()
+    strip = f"{strip_prefix}/" if strip_prefix else None
     with zipfile.ZipFile(zip_path) as zf:
         targets: dict[str, Path] = {}
         for info in zf.infolist():
             if info.is_dir():
                 continue
-            target = (dest / info.filename).resolve()
+            name = info.filename
+            if strip:
+                if not name.startswith(strip):
+                    # Shouldn't happen given how strip_prefix is detected
+                    # (every entry shares it), but never silently misplace
+                    # a file if it somehow doesn't.
+                    continue
+                name = name[len(strip):]
+                if not name:
+                    continue
+            target = (dest / name).resolve()
             if not _is_within(target, dest):
                 raise UnsafeZipEntryError(
                     f"Refusing to apply: entry '{info.filename}' resolves "
@@ -340,12 +363,53 @@ def _safe_extract(zip_path: Path, dest: Path) -> None:
         for info in zf.infolist():
             if info.is_dir():
                 continue
-            target = targets[info.filename]
+            target = targets.get(info.filename)
+            if target is None:
+                continue
             target.parent.mkdir(parents=True, exist_ok=True)
             with zf.open(info) as src, target.open("wb") as out:
                 shutil.copyfileobj(src, out)
 
 
+# ---------------------------------------------------------------------------
+# Wrapper-folder detection ((1) in the apply-zip structure fix)
+# ---------------------------------------------------------------------------
+
+
+def _detect_common_wrapper(names: list[str]) -> str | None:
+    """
+    If every entry in *names* is nested one level under the exact same
+    single top-level directory, return that directory's name — otherwise
+    None. This is the shape produced by `zip -r out.zip myfolder`, GitHub's
+    "Download ZIP" (`repo-branch/...`), and similar: an incidental wrapper
+    around the real, root-relative paths, rather than an intentional part
+    of the project's structure.
+
+    Deliberately conservative: a single root-level file mixed in with the
+    rest (no wrapper actually applies), or more than one top-level
+    directory, both return None rather than guessing.
+    """
+    if not names:
+        return None
+    tops: set[str] = set()
+    for n in names:
+        if "/" not in n:
+            return None
+        tops.add(n.split("/", 1)[0])
+    if len(tops) != 1:
+        return None
+    candidate = next(iter(tops))
+    return candidate or None
+
+
+def _match_rate(names: list[str], manifest_files: dict) -> float:
+    """Fraction of *names* that appear as a path in *manifest_files*."""
+    if not names:
+        return 0.0
+    known = sum(1 for n in names if n in manifest_files)
+    return known / len(names)
+
+
 # ---------------------------------------------------------------------------
 # Building the plan
 # ---------------------------------------------------------------------------
@@ -360,12 +424,55 @@ def build_plan(
     Extract *zip_path* to a temp directory and classify every file against
     *manifest_path* (may be None). Caller is responsible for eventually
     calling `execute_plan` or `discard_plan` to clean up the temp dir.
+
+    Before extracting, checks whether every entry in the zip shares a
+    single wrapping top-level directory (e.g. `codebase/contextzip/...`)
+    that isn't actually part of the project — see `_detect_common_wrapper`.
+    If so, and stripping it would line paths up with the manifest better
+    than leaving them alone, it's stripped automatically. Separately, if a
+    manifest exists and almost none of the resulting paths match it,
+    `structure_warning` is set so the caller can make sure the person
+    actually looks before applying — a zip whose files come out looking
+    all-new is exactly what a silently-mismatched structure produces.
     """
     manifest = load_manifest(manifest_path) if manifest_path else {}
     manifest_files: dict = manifest.get("files", {}) if manifest else {}
 
+    with zipfile.ZipFile(zip_path) as zf:
+        raw_names = sorted(i.filename for i in zf.infolist() if not i.is_dir())
+
+    strip_prefix: str | None = None
+    wrapper_note: str | None = None
+    candidate = _detect_common_wrapper(raw_names)
+    if candidate and not (project_dir / candidate).is_dir():
+        if manifest_files:
+            unstripped_rate = _match_rate(raw_names, manifest_files)
+            stripped_names = [n[len(candidate) + 1:] for n in raw_names]
+            stripped_rate = _match_rate(stripped_names, manifest_files)
+            # Only strip when it clearly helps — meaningfully better match
+            # against paths we know this project actually has, not just a
+            # coincidental improvement on a tiny zip.
+            if stripped_rate > unstripped_rate and stripped_rate >= 0.5:
+                strip_prefix = candidate
+                wrapper_note = (
+                    f"Removed wrapping folder '{candidate}/' present in every "
+                    f"zip entry — {stripped_rate:.0%} of paths matched the "
+                    f"project manifest after stripping vs {unstripped_rate:.0%} "
+                    "before."
+                )
+        else:
+            # No manifest to confirm against, so this is a softer call —
+            # still strip (matches how `tar` and GitHub's own zip downloads
+            # behave), but say so plainly since it's not manifest-verified.
+            strip_prefix = candidate
+            wrapper_note = (
+                f"Removed wrapping folder '{candidate}/' present in every zip "
+                "entry (no manifest available to confirm — double-check the "
+                "result before trusting it)."
+            )
+
     extraction_dir = Path(tempfile.mkdtemp(prefix="contextzip-apply-"))
-    _safe_extract(zip_path, extraction_dir)
+    _safe_extract(zip_path, extraction_dir, strip_prefix=strip_prefix)
 
     entries: list[ApplyEntry] = []
     for extracted in sorted(extraction_dir.rglob("*")):
@@ -406,11 +513,30 @@ def build_plan(
             ApplyEntry(rel_path=rel, status=status, size=size, extracted_path=extracted)
         )
 
+    structure_warning: str | None = None
+    if manifest_files and len(entries) >= 3:
+        known = sum(1 for e in entries if e.rel_path in manifest_files)
+        rate = known / len(entries)
+        if rate < 0.1:
+            structure_warning = (
+                f"Only {known} of {len(entries)} files in this zip match paths "
+                "from the project manifest, even after checking for a wrapping "
+                "folder. That usually means the zip's internal structure "
+                "doesn't line up with this project — the wrong zip, or one "
+                "built with an unexpected layout. Applying it as-is will "
+                "likely create a pile of unrelated new files rather than "
+                "update the ones you meant to change. Double-check the zip "
+                "before proceeding."
+            )
+
     return ApplyPlan(
         zip_path=zip_path,
         manifest_path=manifest_path,
         entries=entries,
         extraction_dir=extraction_dir,
+        wrapper_stripped=strip_prefix,
+        wrapper_note=wrapper_note,
+        structure_warning=structure_warning,
     )
 
 
@@ -447,18 +573,39 @@ def _backup_entries(
     return backup_dir
 
 
-def _move_zip_to_applied(zip_path: Path, project_dir: Path, workspace_root: Path) -> Path:
+def _move_zip_to_applied(
+    zip_path: Path, project_dir: Path, workspace_root: Path, retain: int = 1
+) -> Path:
     """
     Move a consumed inbox zip into .contextzip/inbox/applied/, timestamped,
-    so it can't be accidentally re-applied and stays around as an audit
-    trail. Zips passed by an explicit path outside the inbox are left where
-    the user put them rather than being moved unexpectedly.
+    so it can't be accidentally re-applied. Zips passed by an explicit path
+    outside the inbox are left where the user put them rather than being
+    moved unexpectedly.
+
+    Keeps at most *retain* applied zips (default 1 — only the most recent).
+    Filenames are timestamp-prefixed, so a lexicographic sort is also a
+    chronological one; the oldest are pruned first, before this run's zip
+    is moved in, so the folder never holds more than *retain* at once.
+    Typically a project's `applied_zip_retention` preference
+    (.contextzip/config.json) — raise it to keep a longer audit trail.
     """
     if zip_path.parent.resolve() != inbox_dir(project_dir).resolve():
         return zip_path
 
     applied_dir = workspace_root / _INBOX_DIRNAME / _APPLIED_DIRNAME
     applied_dir.mkdir(parents=True, exist_ok=True)
+
+    retain = max(1, retain)
+    existing = sorted(applied_dir.glob("*.zip"))
+    # Keep room for the zip we're about to add: prune down to retain - 1
+    # existing entries before moving the new one in.
+    overflow = len(existing) - (retain - 1)
+    for old in existing[: max(0, overflow)]:
+        try:
+            old.unlink()
+        except OSError:
+            pass  # best-effort — a leftover old zip isn't worth failing the apply over
+
     stamp = time.strftime("%Y%m%d-%H%M%S")
     dest = applied_dir / f"{stamp}-{zip_path.name}"
     try:
@@ -468,13 +615,17 @@ def _move_zip_to_applied(zip_path: Path, project_dir: Path, workspace_root: Path
     return dest
 
 
-def execute_plan(plan: ApplyPlan, project_dir: Path) -> ApplyResult:
+def execute_plan(plan: ApplyPlan, project_dir: Path, retain: int = 1) -> ApplyResult:
     """
     Write every non-unchanged entry from *plan* into the project.
 
     Backs up whatever's about to be overwritten first. Assumes the caller
     has already decided to proceed — dry-run and confirmation prompts are
     handled upstream (see cli.py's `apply-zip` command).
+
+    *retain* caps how many applied zips are kept in
+    .contextzip/inbox/applied/ — typically a project's
+    `applied_zip_retention` preference (.contextzip/config.json).
     """
     workspace_root = _workspace_dir(project_dir)
     to_write = plan.writable_entries
@@ -488,7 +639,9 @@ def execute_plan(plan: ApplyPlan, project_dir: Path) -> ApplyResult:
         shutil.copy2(entry.extracted_path, dest)
         written.append(entry.rel_path)
 
-    applied_zip_path = _move_zip_to_applied(plan.zip_path, project_dir, workspace_root)
+    applied_zip_path = _move_zip_to_applied(
+        plan.zip_path, project_dir, workspace_root, retain=retain
+    )
     shutil.rmtree(plan.extraction_dir, ignore_errors=True)
 
     return ApplyResult(

{contextzip-0.3.8 → contextzip-0.4.0}/contextzip/cli.py

@@ -373,6 +373,7 @@ def cmd_apply_zip(
       .contextzip/backups/<timestamp>/.
     """
     project_dir = Path(os.getcwd()).resolve()
+    project_cfg = load_project_config(project_dir)
 
     console.print()
     console.print(
@@ -424,16 +425,19 @@ def cmd_apply_zip(
         return
 
     if plan.is_risky and not yes:
-        proceed = click.confirm(
-            "  Some files above need a closer look — apply anyway?", default=False
+        prompt = (
+            "  This zip's structure doesn't look right — apply anyway?"
+            if plan.structure_warning
+            else "  Some files above need a closer look — apply anyway?"
         )
+        proceed = click.confirm(prompt, default=False)
         if not proceed:
             console.print("[dim]Cancelled — no files written.[/]")
             discard_plan(plan)
             return
         console.print()
 
-    result = execute_plan(plan, project_dir)
+    result = execute_plan(plan, project_dir, retain=project_cfg.applied_zip_retention)
     print_apply_result(result)
 
 
@@ -919,6 +923,9 @@ def _run(
             resolved = resolve_files_from_git(
                 git_files=git_result.files,
                 project_dir=project_dir,
+                large_file_warn_bytes=int(
+                    project_cfg.limits.max_file_size_mb * 1024 * 1024
+                ),
             )
 
     else:
@@ -957,11 +964,18 @@ def _run(
                 spec=spec,
                 include_only=include_only if include_only else None,
                 force_include=force_include,
+                large_file_warn_bytes=int(
+                    project_cfg.limits.max_file_size_mb * 1024 * 1024
+                ),
             )
 
     # ── File scan summary + warnings ─────────────────────────────────────────
     print_scan_summary(resolved, project_dir, verbose, git_mode=git_changes)
-    print_file_warnings(resolved, project_dir)
+    print_file_warnings(
+        resolved,
+        project_dir,
+        large_file_warn_bytes=int(project_cfg.limits.max_file_size_mb * 1024 * 1024),
+    )
 
     # ── Dry run ──────────────────────────────────────────────────────────────
     if dry_run:
@@ -1023,6 +1037,7 @@ def _run(
             ecosystem=detection.display_name,
             api_key=api_key,
             max_files=project_cfg.ai.max_files,
+            prompt_template=project_cfg.ai.prompt_template,
         )
 
         if not selected_paths:

{contextzip-0.3.8 → contextzip-0.4.0}/contextzip/cli_ai.py

@@ -61,6 +61,7 @@ def run_ai_selection(
     ecosystem: str,
     api_key: str,
     max_files: int | None = None,
+    prompt_template: str = "",
     con: Console = console,
 ) -> tuple[list[Path], str]:
     """
@@ -70,6 +71,9 @@ def run_ai_selection(
     project's `ai.max_files` preference (.contextzip/config.json). None
     falls back to each backend's own built-in default.
 
+    *prompt_template*, if non-empty, is a project's `ai.prompt_template`
+    preference, prepended to the generated prompt.txt.
+
     Handles progress display, heuristic-fallback warning, and Gemini
     errors. Raises SystemExit(1) on hard failure.
     """
@@ -86,6 +90,7 @@ def run_ai_selection(
                 ecosystem=ecosystem,
                 api_key=api_key,
                 max_files=max_files,
+                prompt_template=prompt_template,
             )
         except GeminiError as exc:
             con.print(