@codebend3r/che 1.1.0 → 1.2.0

package/bin/video/rename-video-file.py

@@ -20,17 +20,19 @@ from __future__ import annotations
 import os
 import re
 import sys
+from dataclasses import dataclass
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from media import LIBRARY_EXTENSIONS
 from utils import (
     add_bool_flag,
     build_parser,
     info,
     iter_files,
     log,
-    note,
+    note_settings,
     run_cli,
     scan_root,
     warning,
@@ -38,8 +40,6 @@ from utils import (
 
 __version__ = "3.0.0"
 
-VIDEO_EXTENSIONS = ("mp4", "mkv")
-
 # Every flavour of curly quote, backtick and acute accent people end up with,
 # normalised to a plain straight apostrophe.
 _APOSTROPHES = str.maketrans({"’": "'", "‘": "'", "´": "'", "`": "'"})  # noqa: RUF001
@@ -100,8 +100,8 @@ def title_case(text: str, pattern: re.Pattern[str]) -> str:
     def replace(match: re.Match[str]) -> str:
         if match.group("code"):
             return match.group("code").upper()
-        if "keep" in match.groupdict() and match.group("keep"):
-            return match.group("keep")
+        if keep := match.groupdict().get("keep"):
+            return keep
         return match.group("first").upper() + match.group("rest").lower()
 
     return pattern.sub(replace, text)
@@ -123,51 +123,59 @@ def normalize(text: str) -> str:
     return _CODE_REJOIN.sub(r"\1-\2", text)
 
 
-def clean_segment(text: str, pattern: re.Pattern[str], *, capitalize_preps: bool) -> str:
-    """Title-case one name segment end to end."""
-    result = title_case(text, pattern)
-    if not capitalize_preps:
-        result = apply_preposition_rules(result)
-    return result
+def _lower_contractions(text: str) -> str:
+    """Lowercase the one or two letters after an apostrophe: "It'S" -> "It's"."""
+    return _APOSTROPHE_SUFFIX.sub(lambda m: "'" + m.group(1).lower(), text)
 
 
-def clean_folder_name(name: str, pattern: re.Pattern[str], *, capitalize_preps: bool) -> str:
-    """The corrected name for a folder.
+@dataclass(frozen=True)
+class TitleCaser:
+    """The casing policy for one run: the words to keep, and the prepositions rule."""
 
-    Folders now get the same curly-quote normalisation as files. The shell
-    version appeared to do this too, but both of its folder-branch sed patterns
-    were the plain ASCII apostrophe - two no-ops - so a folder called
-    ``l'auberge`` with a typographic apostrophe was left alone.
-    """
-    result = clean_segment(normalize(name), pattern, capitalize_preps=capitalize_preps)
-    return _APOSTROPHE_SUFFIX.sub(lambda m: "'" + m.group(1).lower(), result)
+    pattern: re.Pattern[str]
+    capitalize_preps: bool
 
+    @classmethod
+    def build(cls, ignore_words: list[str], *, capitalize_preps: bool) -> TitleCaser:
+        return cls(build_title_pattern(ignore_words), capitalize_preps)
 
-def clean_file_name(name: str, pattern: re.Pattern[str], *, capitalize_preps: bool) -> str | None:
-    """The corrected name for a file, or None when it cannot be parsed.
+    def segment(self, text: str) -> str:
+        """Title-case one name segment end to end."""
+        result = title_case(text, self.pattern)
+        return result if self.capitalize_preps else apply_preposition_rules(result)
 
-    Anchored with ``fullmatch`` where the shell version used an unanchored
-    ``[[ =~ ]]`` search. The two agree on every ordinary name; the difference
-    is dot-leading ones, where the shell version matched from after the dot and
-    so renamed ``.hidden movie.mkv`` to ``Hidden Movie.mkv`` - silently
-    un-hiding the file. Those are reported as unparseable instead.
-    """
-    normalized = normalize(name)
+    def folder_name(self, name: str) -> str:
+        """The corrected name for a folder.
+
+        Folders now get the same curly-quote normalisation as files. The shell
+        version appeared to do this too, but both of its folder-branch sed
+        patterns were the plain ASCII apostrophe - two no-ops - so a folder
+        called ``l'auberge`` with a typographic apostrophe was left alone.
+        """
+        return _lower_contractions(self.segment(normalize(name)))
+
+    def file_name(self, name: str) -> str | None:
+        """The corrected name for a file, or None when it cannot be parsed.
 
-    match = _DASHED_NAME.fullmatch(normalized)
-    if match:
-        prefix, title, ext = match.group(1), match.group(2), match.group(3)
-    else:
-        match = _PLAIN_NAME.fullmatch(normalized)
-        if not match:
-            return None
-        prefix, title, ext = "", match.group(1), match.group(2)
+        Anchored with ``fullmatch`` where the shell version used an unanchored
+        ``[[ =~ ]]`` search. The two agree on every ordinary name; the
+        difference is dot-leading ones, where the shell version matched from
+        after the dot and so renamed ``.hidden movie.mkv`` to ``Hidden
+        Movie.mkv`` - silently un-hiding the file. Those are reported as
+        unparseable instead.
+        """
+        normalized = normalize(name)
 
-    prefix = clean_segment(prefix, pattern, capitalize_preps=capitalize_preps)
-    title = clean_segment(title, pattern, capitalize_preps=capitalize_preps)
+        match = _DASHED_NAME.fullmatch(normalized)
+        if match:
+            prefix, title, ext = match.group(1), match.group(2), match.group(3)
+        else:
+            match = _PLAIN_NAME.fullmatch(normalized)
+            if not match:
+                return None
+            prefix, title, ext = "", match.group(1), match.group(2)
 
-    result = f"{prefix}{title}{ext}"
-    return _APOSTROPHE_SUFFIX.sub(lambda m: "'" + m.group(1).lower(), result)
+        return _lower_contractions(f"{self.segment(prefix)}{self.segment(title)}{ext}")
 
 
 def safe_rename(source: Path, target: Path, *, kind: str) -> bool:
@@ -192,29 +200,28 @@ def safe_rename(source: Path, target: Path, *, kind: str) -> bool:
     return True
 
 
-def rename_folders(
-    root: Path, pattern: re.Pattern[str], *, recursive: bool, capitalize_preps: bool, dry_run: bool
-) -> None:
+def rename_folders(root: Path, caser: TitleCaser, *, recursive: bool, dry_run: bool) -> None:
     """Rename folders deepest-first so a parent rename cannot break child paths."""
     directories: list[Path] = []
-    for dirpath, _, _ in os.walk(root, topdown=False, followlinks=False):
+    for dirpath, dirnames, _ in os.walk(root, followlinks=False):
         directory = Path(dirpath)
         if directory == root:
             continue
-        if not recursive and directory.parent != root:
-            continue
         directories.append(directory)
+        # Not recursive: the root's own children are the only folders renamed,
+        # so the walk need not open anything below them.
+        if not recursive:
+            dirnames.clear()
 
-    # Sorting the collected list, not os.walk's dirnames: under topdown=False
-    # the recursion has already happened, so mutating dirnames does nothing.
-    # Deepest first, so renaming a parent cannot invalidate a child's path.
+    # The walk is top-down, so the list is re-sorted: deepest first, so
+    # renaming a parent cannot invalidate a child's path.
     directories.sort(key=lambda p: (-len(p.parts), p))
 
     for folder in directories:
         if folder.name.startswith("._"):
             continue
 
-        new_name = clean_folder_name(folder.name, pattern, capitalize_preps=capitalize_preps)
+        new_name = caser.folder_name(folder.name)
         if new_name == folder.name:
             warning(f"⚠️ Skipping folder (already correct format): {folder.name}")
             continue
@@ -228,16 +235,14 @@ def rename_folders(
             log(f"📁 Renaming folder: {folder.name} ➡️ {new_name}")
 
 
-def rename_files(
-    root: Path, pattern: re.Pattern[str], *, recursive: bool, capitalize_preps: bool, dry_run: bool
-) -> None:
+def rename_files(root: Path, caser: TitleCaser, *, recursive: bool, dry_run: bool) -> None:
     """Rename the .mp4/.mkv files themselves."""
     # case_sensitive: this script's find used -name, not -iname, so a file
     # called "Movie.MKV" was never renamed.
     for path in iter_files(
-        root, extensions=VIDEO_EXTENSIONS, recursive=recursive, case_sensitive=True
+        root, extensions=LIBRARY_EXTENSIONS, recursive=recursive, case_sensitive=True
     ):
-        new_name = clean_file_name(path.name, pattern, capitalize_preps=capitalize_preps)
+        new_name = caser.file_name(path.name)
         if new_name is None:
             warning(f"Could not parse filename: {path.name}")
             continue
@@ -262,13 +267,10 @@ def main(argv: list[str] | None = None) -> int:
     )
     parser.add_argument("--path", default="", metavar="DIR", help="Directory to scan (required)")
     add_bool_flag(parser, "--recursive", default=True, help="Recurse into subdirectories")
-    add_bool_flag(
-        parser, "--rename-folders", dest="rename_folders", default=True, help="Rename folders too"
-    )
+    add_bool_flag(parser, "--rename-folders", default=True, help="Rename folders too")
     add_bool_flag(
         parser,
         "--capitalize-preps",
-        dest="capitalize_preps",
         help="Capitalize articles and prepositions",
     )
     # Deliberately NOT env_bool: unlike the delete tools, the shell version
@@ -284,7 +286,6 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument(
         "--ignore-words",
         default="",
-        dest="ignore_words",
         metavar="LIST",
         help="Comma-separated words to leave exactly as written",
     )
@@ -294,34 +295,23 @@ def main(argv: list[str] | None = None) -> int:
 
     ignore_words = [word.strip() for word in args.ignore_words.split(",") if word.strip()]
 
-    note(f"Scanning: {args.path}")
-    note(f"Recursive: {str(args.recursive).lower()}")
-    note(f"Rename Folders: {str(args.rename_folders).lower()}")
-    note(f"Capitalize Prepositions: {str(args.capitalize_preps).lower()}")
-    note(f"Dry Run: {str(args.dry_run).lower()}")
+    settings: list[tuple[str, object]] = [
+        ("Scanning", args.path),
+        ("Recursive", args.recursive),
+        ("Rename Folders", args.rename_folders),
+        ("Capitalize Prepositions", args.capitalize_preps),
+        ("Dry Run", args.dry_run),
+    ]
     if ignore_words:
-        note(f"Ignore Words: {','.join(ignore_words)}")
-    note("----------------------------------------------------")
+        settings.append(("Ignore Words", ",".join(ignore_words)))
+    note_settings(*settings)
 
     root = scan_root(args.path)
-    pattern = build_title_pattern(ignore_words)
+    caser = TitleCaser.build(ignore_words, capitalize_preps=args.capitalize_preps)
 
     if args.rename_folders:
-        rename_folders(
-            root,
-            pattern,
-            recursive=args.recursive,
-            capitalize_preps=args.capitalize_preps,
-            dry_run=args.dry_run,
-        )
-
-    rename_files(
-        root,
-        pattern,
-        recursive=args.recursive,
-        capitalize_preps=args.capitalize_preps,
-        dry_run=args.dry_run,
-    )
+        rename_folders(root, caser, recursive=args.recursive, dry_run=args.dry_run)
+    rename_files(root, caser, recursive=args.recursive, dry_run=args.dry_run)
     return 0
 
 

package/bin/video/scan-videos-audio-language.py

@@ -16,20 +16,19 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from media import probe_media
 from utils import (
-    NC,
     build_parser,
-    color_enabled,
-    ffprobe_entries,
     info,
     iter_files,
+    paint,
     require_binary,
     run_cli,
     scan_root,
     warning,
 )
 
-__version__ = "3.0.0"
+__version__ = "3.1.0"
 
 VIDEO_EXTENSIONS = ("mp4", "mkv", "avi", "mov", "flv", "wmv", "webm")
 
@@ -49,22 +48,6 @@ LANG_COLOR = {
 DEFAULT_COLOR = "\033[90m"  # Gray for unknown languages
 
 
-_UNREADABLE = "\x00unreadable"
-
-
-def audio_languages(path: Path) -> list[str] | None:
-    """Sorted, de-duplicated language tags, or None when ffprobe cannot read it.
-
-    Telling "no language tags" apart from "could not be read" matters: the
-    shell version aborted the whole scan on an unreadable file (`set -e` on a
-    failing command substitution), so it never had to render the difference.
-    """
-    raw = ffprobe_entries(path, "stream_tags=language", stream="a", on_error=_UNREADABLE)
-    if raw == _UNREADABLE:
-        return None
-    return sorted({line.strip() for line in raw.splitlines() if line.strip()})
-
-
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser(
         prog="scan-videos-audio-language",
@@ -74,28 +57,28 @@ def main(argv: list[str] | None = None) -> int:
     info(f"Running command in {Path.cwd()}")
     args = parser.parse_args(argv)
 
-    if not args.path:
-        info(f"❌ Error: '{args.path}' is not a valid directory")
-        return 1
-
+    # An empty --path reads "--path is required", where the shell version
+    # reported `'' is not a valid directory`.
     root = scan_root(args.path)
 
     require_binary("ffprobe", hint="ffprobe (from ffmpeg) is required but not installed.")
 
-    # The per-language escapes are baked into the string before info() sees
-    # it, so NO_COLOR has to be honoured here as well or it would leak.
-    colors = color_enabled()
-
-    def paint(text: str, color: str) -> str:
-        return f"{color}{text}{NC}" if colors else text
-
     for path in iter_files(root, extensions=VIDEO_EXTENSIONS):
         info(f"File: {path}")
 
-        languages = audio_languages(path)
-        if languages is None:
+        # Telling "no language tags" apart from "could not be read" matters:
+        # the shell version aborted the whole scan on an unreadable file
+        # (`set -e` on a failing command substitution), so it never had to
+        # render the difference.
+        probe = probe_media(path)
+        if probe is None:
             warning(f"Audio language(s): {paint('Unreadable - ffprobe failed', DEFAULT_COLOR)}")
             continue
+
+        # DELIBERATE DIVERGENCE: the shell version's csv output read `und,`
+        # for AC3 or E-AC3 audio in an MP4 on ffprobe 9 (see MediaProbe), and
+        # a bare `,` when such a stream had no tag. Both now read cleanly.
+        languages = probe.languages("audio")
         if not languages:
             info(f"Audio language(s): {paint('Unknown or not tagged', DEFAULT_COLOR)}")
             continue

package/bin/video/show-codecs.py

@@ -17,21 +17,21 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from media import CODEC_SCAN_EXTENSIONS, probe_media
 from utils import (
     add_bool_flag,
     build_parser,
-    ffprobe_entries,
     info,
     iter_files,
     log,
-    note,
+    note_settings,
     require_binary,
     run_cli,
     scan_root,
     warning,
 )
 
-__version__ = "3.0.0"
+__version__ = "3.1.0"
 
 # The common safe set for Direct Play. Tuples, not sets, so the banner prints
 # them in the order the shell version's arrays declared them.
@@ -39,8 +39,6 @@ ALLOWED_VIDEO_CODECS = ("h264", "hevc")
 ALLOWED_AUDIO_CODECS = ("aac", "ac3", "eac3")
 ALLOWED_CONTAINERS = ("mov", "mp4", "mkv")
 
-SCAN_EXTENSIONS = ("mp4", "mkv", "mov", "avi")
-
 
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser(
@@ -52,18 +50,12 @@ def main(argv: list[str] | None = None) -> int:
     info(f"Running command in {Path.cwd()}")
     args = parser.parse_args(argv)
 
-    note(f"Scanning: {args.path}")
-    note(f"Verbose: {str(args.verbose).lower()}")
-    note("----------------------------------------------------")
+    note_settings(("Scanning", args.path), ("Verbose", args.verbose))
 
-    if not args.path:
-        warning("❌ --path is required")
-        return 1
+    root = scan_root(args.path)
 
     require_binary("ffprobe", hint="Install FFmpeg: brew install ffmpeg")
 
-    root = scan_root(args.path)
-
     print(f"Scanning for problematic codecs in: {args.path}")
     print(f"Allowed Video: {' '.join(ALLOWED_VIDEO_CODECS)}")
     print(f"Allowed Audio: {' '.join(ALLOWED_AUDIO_CODECS)}")
@@ -72,19 +64,23 @@ def main(argv: list[str] | None = None) -> int:
 
     problems = 0
 
-    for path in iter_files(root, extensions=SCAN_EXTENSIONS):
+    for path in iter_files(root, extensions=CODEC_SCAN_EXTENSIONS):
         container = path.name.lower().rsplit(".", 1)[-1]
 
-        # "unknown" only when ffprobe itself FAILS (a corrupt file), matching
-        # the shell version's `|| echo "unknown"`. A file that probes fine but
-        # has no audio track keeps the empty string the shell version stored,
-        # so the two cases stay distinguishable in the report.
-        video_codec = ffprobe_entries(
-            path, "stream=codec_name", stream="v:0", on_error="unknown"
-        ).lower()
-        audio_codec = ffprobe_entries(
-            path, "stream=codec_name", stream="a:0", on_error="unknown"
-        ).lower()
+        # "unknown" when ffprobe itself FAILS (a corrupt file), matching the
+        # shell version's `|| echo "unknown"`, or when it cannot name a codec.
+        # A file that probes fine but has no audio track keeps the empty
+        # string the shell version stored, so the cases stay distinguishable.
+        #
+        # DELIBERATE DIVERGENCE: the shell version's csv output read `ac3,`
+        # for AC3 or E-AC3 audio in an MP4 on ffprobe 9 (see MediaProbe), so
+        # every such file failed the allowed-codec check. They now pass.
+        probe = probe_media(path)
+        if probe is None:
+            video_codec = audio_codec = "unknown"
+        else:
+            video_codec = probe.codec("video").lower()
+            audio_codec = probe.codec("audio").lower()
 
         ok = (
             video_codec in ALLOWED_VIDEO_CODECS

package/bin/video/validate-video-files.py

@@ -18,6 +18,7 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from media import LIBRARY_EXTENSIONS
 from utils import (
     add_bool_flag,
     build_parser,
@@ -31,9 +32,7 @@ from utils import (
     warning,
 )
 
-__version__ = "3.0.0"
-
-VIDEO_EXTENSIONS = ("mp4", "mkv")
+__version__ = "3.1.0"
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -46,10 +45,8 @@ def main(argv: list[str] | None = None) -> int:
     info(f"Running command in {Path.cwd()}")
     args = parser.parse_args(argv)
 
-    if not args.path:
-        warning(f"❌ Error: '{args.path}' is not a valid directory")
-        return 1
-
+    # An empty --path reads "--path is required", where the shell version
+    # reported `'' is not a valid directory`.
     root = scan_root(args.path)
 
     require_binary("mpv", hint="Install it using Homebrew:\n  brew install mpv")
@@ -57,7 +54,7 @@ def main(argv: list[str] | None = None) -> int:
     checked = 0
     bad: list[Path] = []
 
-    for path in iter_files(root, extensions=VIDEO_EXTENSIONS):
+    for path in iter_files(root, extensions=LIBRARY_EXTENSIONS):
         # The shell version gated this on `[[ -z "$VERBOSE" ]]`, but VERBOSE is
         # the literal string "false" when unset, which is never empty - so the
         # line never printed and --verbose did nothing. Wired up properly here.

package/bin/video/video-list.py

@@ -21,10 +21,10 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from media import LIBRARY_EXTENSIONS
 from utils import (
     CYAN,
     GREEN,
-    NC,
     YELLOW,
     add_bool_flag,
     build_parser,
@@ -32,15 +32,14 @@ from utils import (
     info,
     iter_files,
     log,
-    note,
+    note_settings,
+    paint,
     run_cli,
     scan_root,
-    warning,
 )
 
-__version__ = "3.0.0"
+__version__ = "3.1.0"
 
-VIDEO_EXTENSIONS = ("mp4", "mkv")
 SORT_METHODS = ("alpha", "fileSizeAsc", "fileSizeDesc")
 
 
@@ -51,7 +50,7 @@ def main(argv: list[str] | None = None) -> int:
     )
     parser.add_argument("--path", default="", metavar="DIR", help="Directory to scan (required)")
     add_bool_flag(parser, "--recursive", help="Recurse into subdirectories")
-    add_bool_flag(parser, "--with-folder", dest="with_folder", help="Prefix with folder name")
+    add_bool_flag(parser, "--with-folder", help="Prefix with folder name")
     parser.add_argument(
         "--sort",
         default="alpha",
@@ -62,15 +61,12 @@ def main(argv: list[str] | None = None) -> int:
     info(f"Running command in {Path.cwd()}")
     args = parser.parse_args(argv)
 
-    note(f"Scanning: {args.path}")
-    note(f"Recursive: {str(args.recursive).lower()}")
-    note(f"Sort method: {args.sort}")
-    note(f"With folder: {str(args.with_folder).lower()}")
-    note("----------------------------------------------------")
-
-    if not args.path:
-        warning("❌ --path is required")
-        return 1
+    note_settings(
+        ("Scanning", args.path),
+        ("Recursive", args.recursive),
+        ("Sort method", args.sort),
+        ("With folder", args.with_folder),
+    )
 
     # Replaces the shell version's `find` error on a missing path with a
     # styled message; the exit code is unchanged.
@@ -79,7 +75,7 @@ def main(argv: list[str] | None = None) -> int:
     entries: list[tuple[int, Path]] = []
     for path in iter_files(
         root,
-        extensions=VIDEO_EXTENSIONS,
+        extensions=LIBRARY_EXTENSIONS,
         recursive=args.recursive,
         skip_hidden=True,
     ):
@@ -101,16 +97,17 @@ def main(argv: list[str] | None = None) -> int:
         locale.setlocale(locale.LC_COLLATE, "")
         entries.sort(key=lambda item: locale.strxfrm(str(item[1])))
 
+    # DELIBERATE DIVERGENCE: the shell version baked these escapes into every
+    # line unconditionally, so NO_COLOR or a pipe still got them raw. paint()
+    # honours both, like every other coloured line in the repo.
     for size, path in entries:
-        size_human = format_bytes(size)
+        display = f"{paint(path.name, GREEN)} {paint(f'[{format_bytes(size)}]', YELLOW)}"
         if args.with_folder:
             # `basename $(dirname ./x.mkv)` is ".", but pathlib collapses the
             # "." away and leaves parent.name empty - which would render as a
             # bare leading slash and read like an absolute path.
             folder = path.parent.name or path.parent.as_posix()
-            display = f"{CYAN}{folder}{NC}/{GREEN}{path.name}{NC} {YELLOW}[{size_human}]{NC}"
-        else:
-            display = f"{GREEN}{path.name}{NC} {YELLOW}[{size_human}]{NC}"
+            display = f"{paint(folder, CYAN)}/{display}"
         log(display)
 
     return 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebend3r/che",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Helper scripts shared across machines, called by name from your shell and browsable through one menu",
   "keywords": [
     "cli",
@@ -27,7 +27,6 @@
   "files": [
     "bin/",
     "shell/",
-    "!bin/version-bump.py",
     "!**/__pycache__/",
     "!**/*.pyc"
   ],
@@ -36,19 +35,14 @@
   },
   "scripts": {
     "test": "uv run --no-project --with-requirements requirements-dev.txt -- pytest",
-    "ci": "run-s lint format syntax executable shebang generated test",
+    "ci": "bun run --sequential lint format executable shebang test",
     "lint": "uv run --no-project --with-requirements requirements-dev.txt -- ruff check bin test",
     "format": "uv run --no-project --with-requirements requirements-dev.txt -- ruff format --check bin test",
-    "syntax": "find bin test -type f -name '*.py' -print0 | xargs -0 -n1 python3 -m py_compile",
     "executable": "find bin -type f -name '*.py' ! -perm -u+x -print0 | xargs -0 awk 'FNR==1 && /^#!/{print \"Has a shebang but is not executable: \" FILENAME; ec=1} END{exit ec+0}'",
     "shebang": "find bin -type f -name '*.py' -perm -u+x -print0 | xargs -0 awk 'FNR==1 && !/^#!/{print \"Executable but has no shebang: \" FILENAME; ec=1} END{exit ec+0}'",
-    "generate": "python3 bin/install.py --generate",
-    "generated": "python3 bin/install.py --check",
+    "generate": "python3 bin/shellgen.py",
     "version": "bun run generate && git add shell .zshrc README.md",
     "prepublishOnly": "bun run ci"
   },
-  "packageManager": "bun@1.3.14",
-  "devDependencies": {
-    "npm-run-all2": "9.0.1"
-  }
+  "packageManager": "bun@1.4.2"
 }