may be optimized. work in progress

Author: snakewayz

chomp/README.md

@@ -93,7 +93,7 @@ Environment variable `CHOMP_REPO` overrides the repo root (default: `./chomp`).
 ## Repository layout (auto-created)
 
 ```
-chomp/
+chomp.out/
   nupkgs/          ← downloaded .nupkg cache
   installers/      ← staged installer binaries
   out/
@@ -141,7 +141,42 @@ manifests/
 
 ---
 
-## URL filtering
+## Error handling
+
+CHOMP distinguishes three error classes:
+
+**Per-package / per-download failures** — logged inline with `✗` and included in the summary and manifest. The run continues with remaining packages.
+
+**Fatal errors** (bad args, missing mode, unreadable directory) — printed as a clean one-liner to stderr and exit code 1:
+
+```
+error: rewrite mode requires --base-url
+```
+
+**Interrupted runs** (`Ctrl-C`) — prints a clean abort line and any partial progress before exiting with code 130:
+
+```
+interrupted (ctrl-c)
+  3 installer(s) downloaded before interrupt
+```
+
+### Tracebacks
+
+By default, tracebacks are suppressed for clean output. Enable them two ways:
+
+```bash
+# via flag (also enables verbose debug output)
+chomp internalize googlechrome -v
+
+# via environment variable (traceback only, no extra verbosity)
+CHOMP_TRACEBACK=1 chomp internalize googlechrome
+```
+
+Exit codes: `0` success, `1` error, `2` bad arguments, `130` interrupted.
+
+---
+
+
 
 CHOMP skips URLs that aren't downloadable installer paths:
 

chomp/src/chomp/__init__.py

@@ -8,11 +8,11 @@
     resolve_with_deps,
 )
 from .manifest import print_summary, write_csv, write_json
-from .repack import finalize_nupkg, process_nupkg_phase1
+from .repack import build_nupkg, collect_urls
 
 __all__ = [
-    "process_nupkg_phase1",
-    "finalize_nupkg",
+    "collect_urls",
+    "build_nupkg",
     "download_batch",
     "installer_path",
     "resolve_package",

chomp/src/chomp/cli.py

@@ -18,8 +18,20 @@
 from .download import download_batch, installer_path, print_failed
 from .fetch import resolve_and_download_packages, resolve_with_deps
 from .manifest import print_summary, write_csv, write_json
-from .repack import finalize_nupkg, process_nupkg_phase1
-from .term import bold, dim, err, info, ok, section, set_verbose, warn
+from .repack import build_nupkg, collect_urls
+from .term import (
+    abort,
+    bold,
+    dim,
+    err,
+    fatal,
+    info,
+    ok,
+    section,
+    set_verbose,
+    vlog,
+    warn,
+)
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -181,63 +193,69 @@ def main(argv=None) -> int:
             unique.append(n)
     nupkgs = unique
 
-    # ---- Phase 1: rewrite URLs ----
+    # ---- Collect URLs (read-only scan of all nupkgs) ----
     all_mappings = []
-    processed_nupkgs = []  # only nupkgs written this run
-
-    section("Phase 1 — Rewriting URLs")
-    with tempfile.TemporaryDirectory(prefix="chomp_p1_") as tmp:
-        for nupkg in nupkgs:
-            mappings = process_nupkg_phase1(
-                nupkg=nupkg,
-                base_url=base_url,
-                out_dir=out_dir,
-                work_dir=Path(tmp),
-                mode=mode,
-                dry_run=is_dry,
-                force=force,
-            )
-            if mappings is not None:
-                all_mappings.extend(mappings)
-                processed_nupkgs.append(out_dir / nupkg.name)
+    nupkg_mappings: dict[Path, list[dict]] = {}  # per-package URL maps
+
+    section("Phase 1 — Scanning packages")
+    for nupkg in nupkgs:
+        result = collect_urls(
+            nupkg=nupkg,
+            base_url=base_url,
+            out_dir=out_dir,
+            mode=mode,
+            force=force,
+        )
+        if result is None:
+            continue  # already exists, skip
+        nupkg_mappings[nupkg] = result
+        all_mappings.extend(result)
 
-    if not all_mappings:
-        print(warn("No external URLs found."))
+    if not nupkg_mappings:
+        print(warn("Nothing to do."))
         return 0
 
-    # ---- Phase 2: download + finalize ----
-    if not args.skip_download and not is_dry:
+    if is_dry:
+        pass  # fall through to summary
+
+    # ---- Download installers ----
+    elif not args.skip_download:
         section("Phase 2 — Downloading installers")
-        all_mappings = download_batch(
-            items=all_mappings,
-            installer_dir=installer_dir,
-            use_pwsh=args.pwsh,
-            quiet=args.quiet,
-            interactive=args.interactive,
-            force=force,
-        )
+        try:
+            all_mappings = download_batch(
+                items=all_mappings,
+                installer_dir=installer_dir,
+                use_pwsh=args.pwsh,
+                quiet=args.quiet,
+                interactive=args.interactive,
+                force=force,
+            )
+        except KeyboardInterrupt:
+            abort()
+            done = sum(1 for m in all_mappings if m.get("downloaded") == "ok")
+            print(warn(f"  {done} installer(s) downloaded before interrupt"))
+            raise
 
-        section("Phase 2b — Finalizing packages")
+        # ---- Build final nupkgs ----
+        section("Phase 3 — Building packages")
 
         def resolve(m):
             return installer_path(m, installer_dir)
 
-        with tempfile.TemporaryDirectory(prefix="chomp_p2_") as tmp2:
-            for nupkg in processed_nupkgs:
-                if not nupkg.exists():
-                    continue
-                pkg_id = nupkg.stem.split(".")[0]
-                pkg_maps = [m for m in all_mappings if m["package"] == pkg_id]
-                if not pkg_maps:
-                    continue
-                finalize_nupkg(
-                    nupkg=nupkg,
-                    mappings=pkg_maps,
-                    local_file_resolver=resolve,
-                    out_dir=out_dir,
-                    work_dir=Path(tmp2),
-                    mode=mode,
-                )
+        with tempfile.TemporaryDirectory(prefix="chomp_") as tmp:
+            try:
+                for nupkg, mappings in nupkg_mappings.items():
+                    build_nupkg(
+                        nupkg=nupkg,
+                        mappings=mappings,
+                        local_file_resolver=resolve,
+                        out_dir=out_dir,
+                        work_dir=Path(tmp),
+                        mode=mode,
+                    )
+            except KeyboardInterrupt:
+                abort()
+                raise
 
     # ---- Output ----
     if not is_dry:
@@ -257,4 +275,28 @@ def resolve(m):
 
 
 def entry_point():
-    sys.exit(main())
+    import os
+    import traceback
+
+    _show_tb = (
+        os.environ.get("CHOMP_TRACEBACK") or "--verbose" in sys.argv or "-v" in sys.argv
+    )
+
+    try:
+        sys.exit(main())
+    except KeyboardInterrupt:
+        abort()
+        sys.exit(130)
+    except Exception as exc:
+        if _show_tb:
+            traceback.print_exc()
+        else:
+            # Walk cause chain for a useful one-liner
+            msg = str(exc).strip() or type(exc).__name__
+            cause = exc.__cause__ or exc.__context__
+            if cause and str(cause).strip():
+                msg = f"{msg}: {str(cause).strip()}"
+            fatal(
+                msg, hint="re-run with -v for full traceback, or set CHOMP_TRACEBACK=1"
+            )
+        sys.exit(1)

chomp/src/chomp/config.py

@@ -47,7 +47,7 @@ def validate_mode(mode: str) -> str:
 
 
 def get_repo_root() -> Path:
-    return Path(os.environ.get("CHOMP_REPO", "./chomp")).resolve()
+    return Path(os.environ.get("CHOMP_REPO", "./chomp.out")).resolve()
 
 
 def repo_path(root: Path, key: str) -> Path:

chomp/src/chomp/download.py

@@ -67,6 +67,10 @@ def _prompt_url(item: dict, dest: Path) -> dict:
         print(f"  {warn('?')} Enter, s, or e.")
 
 
+def _item_key(item: dict) -> tuple:
+    return (item["package"], item.get("version", ""), item["filename"])
+
+
 def download_batch(
     items: list[dict],
     installer_dir: Path,
@@ -82,7 +86,7 @@ def download_batch(
         print(f"\n{info('── Review URLs (all decisions before downloads start) ──')}")
         resolved, seen = [], set()
         for item in items:
-            key = (item["package"], item.get("version", ""), item["filename"])
+            key = _item_key(item)
             dest = installer_path(item, installer_dir)
             if key in seen:
                 resolved.append(
@@ -101,17 +105,16 @@ def download_batch(
     seen, results = set(), []
     for item in items:
         url = item.get("resolved_url", item["old_url"])
-        key = (item["package"], item.get("version", ""), item["filename"])
+        key = _item_key(item)
         action = item.get("action")
         dest = installer_path(item, installer_dir)
 
-        # Pre-resolved (interactive)
-        if action == "duplicate":
+        if action == "duplicate" or (action is None and key in seen):
             results.append(
                 {**item, "downloaded": "skipped-duplicate", "skip_reason": ""}
             )
             continue
-        if action == "exists":
+        if action == "exists" or (action is None and dest.exists() and not force):
             if not quiet:
                 print(f"  {SKIP} {dim('exists:')} {dim(str(dest))}")
             results.append({**item, "downloaded": "skipped-exists", "skip_reason": ""})
@@ -126,22 +129,8 @@ def download_batch(
             )
             continue
 
-        # Non-interactive dedup
-        if key in seen:
-            results.append(
-                {**item, "downloaded": "skipped-duplicate", "skip_reason": ""}
-            )
-            continue
         seen.add(key)
 
-        # Skip-if-exists (unless --force)
-        if dest.exists() and not force:
-            if not quiet:
-                print(f"  {SKIP} {dim('exists:')} {dim(str(dest))}")
-            results.append({**item, "downloaded": "skipped-exists", "skip_reason": ""})
-            continue
-
-        # URL classification
         should_dl, skip_reason = classify_url(url)
         if not should_dl:
             if not quiet:
@@ -151,7 +140,14 @@ def download_batch(
             )
             continue
 
-        dest.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            dest.parent.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            print(f"  {CROSS} {err('mkdir failed:')} {dim(str(e))}")
+            results.append(
+                {**item, "downloaded": "failed", "skip_reason": f"mkdir: {e}"}
+            )
+            continue
         success, err_msg = _download_one(url, dest, use_pwsh)
         results.append(
             {