codigest 0.4.3__tar.gz → 0.5.0__tar.gz

codigest-0.5.0/.gitattributes

@@ -0,0 +1 @@
+*.sh text eol=lf

{codigest-0.4.3 → codigest-0.5.0}/CITATION.cff

@@ -14,7 +14,7 @@ authors:
 repository-code: "https://github.com/NaNIsaac/codigest"
 url: "https://pypi.org/project/codigest/"
 license: MIT
-version: 0.4.3
+version: 0.5.0
 date-released: "2026-10-15"
 keywords:
   - LLM

{codigest-0.4.3 → codigest-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codigest
-Version: 0.4.3
+Version: 0.5.0
 Summary: Human-Centered Codebase Context Manager for LLMs
 Project-URL: Homepage, https://github.com/NaNIsaac/codigest
 Project-URL: Repository, https://github.com/NaNIsaac/codigest
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
-Requires-Python: >=3.15
+Requires-Python: >=3.15.0b1
 Requires-Dist: loguru
 Requires-Dist: pathspec
 Requires-Dist: pyperclip
@@ -83,6 +83,8 @@ Install Codigest globally. `uv` will automatically manage the required Python 3.
 uv tool install codigest
 ```
 
+Codigest needs Python 3.15. If `uv` reports a syntax error on `lazy import`, it picked an early 3.15 alpha: run `uv self update` (or upgrade uv) and install again.
+
 ### Step 3: Update Path (Important!)
 
 To run `codigest` (or `cdg`) from any terminal, ensure your tools directory is in your PATH.
@@ -219,15 +221,16 @@ Runs a command transparently (output still streams live) and records its command
 * **Safety:** Known secret shapes (API keys, tokens, `password=...`) are redacted before anything touches disk. Output of credential commands (`env`, `printenv`, `gh auth token`, ...) is never stored.
 * **Fallback:** Commands not run through `cap` are read from the native shell history (PowerShell, bash, zsh, fish), without output.
 
-**Automatic capture (PowerShell):** `cdg term install` hooks your PowerShell profile so *every* command is captured without the `cap` prefix. Commands run in your current session (`cd`, variables and functions behave normally). Editors, pagers, REPLs and `ssh` are skipped automatically.
+**Automatic capture (PowerShell, bash, zsh):** `cdg term install` hooks your shells so *every* command is captured without the `cap` prefix. It writes to your PowerShell profile, `~/.bashrc` and `~/.zshrc`, for whichever of these shells is installed; pick one with `--shell powershell|bash|zsh|all`. On Windows, Git Bash counts as bash. Commands run in your current session (`cd`, variables and functions behave normally) and your history shows them as typed. Editors, pagers, REPLs and `ssh` are skipped automatically.
 
 * Skip one command: start the line with a space.
-* Skip more programs: `$env:CODIGEST_CAP_SKIP = '^\s*(myrepl|mytui)\b'`
-* Disable for a session: `$env:CODIGEST_NOCAP = 1`. Remove: `cdg term uninstall`.
+* Skip more programs: `$env:CODIGEST_CAP_SKIP = '^\s*(myrepl|mytui)\b'` (bash/zsh: `export CODIGEST_CAP_SKIP='^(myrepl|mytui)( |$)'`, an extended regex)
+* Disable for a session: `$env:CODIGEST_NOCAP = 1` (bash/zsh: `export CODIGEST_NOCAP=1`). Remove: `cdg term uninstall`.
 * Trade-off: captured programs write to a pipe, not a TTY, so some lose colors or progress bars.
+* bash (4+) and zsh do not capture multi-line commands (loops typed over several lines, heredocs), background jobs (`cmd &`) or lines using `!` history expansion; those run normally.
 
 ```bash
-cdg term install    # PowerShell: capture everything automatically
+cdg term install    # capture everything automatically (PowerShell, bash, zsh)
 
 # Run and capture (prefix with -- so flags reach the command)
 cdg cap -- pytest -q

{codigest-0.4.3 → codigest-0.5.0}/README.md

@@ -57,6 +57,8 @@ Install Codigest globally. `uv` will automatically manage the required Python 3.
 uv tool install codigest
 ```
 
+Codigest needs Python 3.15. If `uv` reports a syntax error on `lazy import`, it picked an early 3.15 alpha: run `uv self update` (or upgrade uv) and install again.
+
 ### Step 3: Update Path (Important!)
 
 To run `codigest` (or `cdg`) from any terminal, ensure your tools directory is in your PATH.
@@ -193,15 +195,16 @@ Runs a command transparently (output still streams live) and records its command
 * **Safety:** Known secret shapes (API keys, tokens, `password=...`) are redacted before anything touches disk. Output of credential commands (`env`, `printenv`, `gh auth token`, ...) is never stored.
 * **Fallback:** Commands not run through `cap` are read from the native shell history (PowerShell, bash, zsh, fish), without output.
 
-**Automatic capture (PowerShell):** `cdg term install` hooks your PowerShell profile so *every* command is captured without the `cap` prefix. Commands run in your current session (`cd`, variables and functions behave normally). Editors, pagers, REPLs and `ssh` are skipped automatically.
+**Automatic capture (PowerShell, bash, zsh):** `cdg term install` hooks your shells so *every* command is captured without the `cap` prefix. It writes to your PowerShell profile, `~/.bashrc` and `~/.zshrc`, for whichever of these shells is installed; pick one with `--shell powershell|bash|zsh|all`. On Windows, Git Bash counts as bash. Commands run in your current session (`cd`, variables and functions behave normally) and your history shows them as typed. Editors, pagers, REPLs and `ssh` are skipped automatically.
 
 * Skip one command: start the line with a space.
-* Skip more programs: `$env:CODIGEST_CAP_SKIP = '^\s*(myrepl|mytui)\b'`
-* Disable for a session: `$env:CODIGEST_NOCAP = 1`. Remove: `cdg term uninstall`.
+* Skip more programs: `$env:CODIGEST_CAP_SKIP = '^\s*(myrepl|mytui)\b'` (bash/zsh: `export CODIGEST_CAP_SKIP='^(myrepl|mytui)( |$)'`, an extended regex)
+* Disable for a session: `$env:CODIGEST_NOCAP = 1` (bash/zsh: `export CODIGEST_NOCAP=1`). Remove: `cdg term uninstall`.
 * Trade-off: captured programs write to a pipe, not a TTY, so some lose colors or progress bars.
+* bash (4+) and zsh do not capture multi-line commands (loops typed over several lines, heredocs), background jobs (`cmd &`) or lines using `!` history expansion; those run normally.
 
 ```bash
-cdg term install    # PowerShell: capture everything automatically
+cdg term install    # capture everything automatically (PowerShell, bash, zsh)
 
 # Run and capture (prefix with -- so flags reach the command)
 cdg cap -- pytest -q

{codigest-0.4.3 → codigest-0.5.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "codigest"
-version = "0.4.3"
+version = "0.5.0"
 description = "Human-Centered Codebase Context Manager for LLMs"
 authors = [{ name = "Isaac Yong", email = "isaacyong@naver.com" }]
 readme = "README.md"
-requires-python = ">=3.15"
+requires-python = ">=3.15.0b1"
 license = { text = "MIT" }
 dependencies = [
     "typer",

{codigest-0.4.3 → codigest-0.5.0}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/NaNIsaac/codigest",
     "source": "github"
   },
-  "version": "0.4.3",
+  "version": "0.5.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "codigest",
-      "version": "0.4.3",
+      "version": "0.5.0",
       "runtimeHint": "uvx",
       "transport": {
         "type": "stdio"

{codigest-0.4.3 → codigest-0.5.0}/src/codigest/commands/term.py

@@ -4,6 +4,7 @@
 import os
 import sys
 import traceback
+from datetime import datetime
 from pathlib import Path
 from typing import Annotated
 
@@ -157,16 +158,44 @@ def path() -> None:
 
 
 @app.command("ingest", hidden=True)
-def ingest() -> None:
-    """Store one JSON entry from stdin (called by the shell hook)."""
+def ingest(
+    file: Annotated[Path | None, typer.Option(help="Command, NUL, output; deleted afterwards")] = None,
+    exit_code: Annotated[int | None, typer.Option()] = None,
+    cwd: Annotated[str, typer.Option()] = "",
+    shell: Annotated[str, typer.Option()] = "",
+    start: Annotated[str, typer.Option(help="Epoch seconds")] = "",
+    end: Annotated[str, typer.Option(help="Epoch seconds")] = "",
+) -> None:
+    """
+    Store one entry (called by the shell hook): JSON on stdin (PowerShell),
+    or options plus a capture file (bash / zsh).
+    """
+    # The command travels in the file, not argv: click expands $VARS in argv on Windows.
     try:
-        data = json.loads(sys.stdin.buffer.read().decode("utf-8-sig"))
+        if file is None:
+            data = json.loads(sys.stdin.buffer.read().decode("utf-8-sig"))
+        else:
+            command, _, output = file.read_bytes().partition(b"\0")
+            # Locales with a decimal comma format $EPOCHREALTIME as 12,5.
+            t0, t1 = (float(t.replace(",", ".")) for t in (start or "0", end or start or "0"))
+            data = {
+                "command": command.decode("utf-8", "replace"),
+                "output": output.decode("utf-8", "replace"),
+                "exit_code": exit_code,
+                "cwd": str(Path(cwd)) if cwd else "",  # Git Bash passes D:/x
+                "shell": shell,
+                "started_at": datetime.fromtimestamp(t0).astimezone().isoformat(timespec="seconds"),
+                "duration_ms": max(0, round((t1 - t0) * 1000)),
+            }
         termstore.append_entry(termstore.Entry.from_dict(data))
     except Exception:
         # The hook discards our stderr; leave a trail `cdg term` can surface.
         with _ingest_log().open("a", encoding="utf-8") as f:
             f.write(f"--- {termstore.now_iso()}\n{traceback.format_exc()}")
         raise typer.Exit(code=1)
+    finally:
+        if file:
+            file.unlink(missing_ok=True)
 
 
 def _ingest_log() -> Path:
@@ -181,18 +210,36 @@ def _diagnose(log) -> None:
             "[dim]Capture hook is not active in this shell. Run `cdg term install` "
             "and open a new window, or enable it now with:[/dim]"
         )
-        log.print(f"[dim]  . '{HOOK_PATH}'[/dim]", highlight=False)
+        log.print(f"[dim]  PowerShell: . '{HOOK_PATH}'[/dim]", highlight=False)
+        log.print(f"[dim]  bash / zsh: . '{_posix(SH_HOOK_PATH)}'[/dim]", highlight=False)
     if (errors := termstore.get_term_dir() / "ingest-errors.log").exists():
         log.print(f"[red]Capture errors were logged:[/red] {errors}", highlight=False)
 
 
 # --------------------------------------------------------------------------
-# PowerShell hook install
+# Hook install (PowerShell profiles, ~/.bashrc, ~/.zshrc)
 # --------------------------------------------------------------------------
 
 HOOK_PATH = Path(__file__).resolve().parent.parent / "shell" / "hook.ps1"
+SH_HOOK_PATH = HOOK_PATH.with_name("hook.sh")
 _BEGIN = "# >>> codigest terminal capture >>>"
 _END = "# <<< codigest terminal capture <<<"
+_SHELLS = ("auto", "powershell", "bash", "zsh", "all")
+
+ShellOption = Annotated[
+    str,
+    typer.Option(
+        "--shell",
+        help="powershell, bash, zsh or all (default: every one installed)",
+    ),
+]
+
+
+def _posix(path: Path) -> str:
+    """C:/x/y -> /c/x/y, the form Git Bash understands."""
+    if path.drive.endswith(":"):
+        return f"/{path.drive[0].lower()}{path.as_posix()[2:]}"
+    return path.as_posix()
 
 
 def _powershell_profiles() -> list[Path]:
@@ -212,6 +259,21 @@ def _powershell_profiles() -> list[Path]:
     return profiles
 
 
+def _targets(shell: str) -> list[Path]:
+    """Startup files for the requested shells; `auto` picks the installed ones."""
+    if shell not in _SHELLS:
+        raise typer.BadParameter(f"choose one of: {', '.join(_SHELLS)}", param_hint="--shell")
+    wants = lambda name: shell in (name, "all") or (shell == "auto" and shutil.which(name))
+    targets = []
+    if shell in ("powershell", "all", "auto"):
+        targets += _powershell_profiles()
+    if wants("bash"):
+        targets.append(Path.home() / ".bashrc")
+    if wants("zsh"):
+        targets.append(Path(os.environ.get("ZDOTDIR") or Path.home()) / ".zshrc")
+    return targets
+
+
 def _strip_block(text: str) -> str:
     start = text.find(_BEGIN)
     end = text.find(_END)
@@ -221,45 +283,55 @@ def _strip_block(text: str) -> str:
     return rest + "\n" if rest else ""
 
 
-def _rewrite_profiles(add: bool) -> None:
+def _rewrite_profiles(add: bool, shell: str) -> None:
     console = Console()
-    if not (profiles := _powershell_profiles()):
-        console.print("[red][Error][/red] No PowerShell found (pwsh / powershell).")
+    # Removing from a file that has no block is a no-op, so uninstall checks every shell.
+    if not (targets := _targets(shell if add or shell != "auto" else "all")):
+        console.print("[red][Error][/red] No supported shell found (PowerShell, bash, zsh).")
         raise typer.Exit(code=1)
 
-    block = f"{_BEGIN}\nif (Test-Path '{HOOK_PATH}') {{ . '{HOOK_PATH}' }}\n{_END}\n"
-    for profile in profiles:
+    sh = _posix(SH_HOOK_PATH)
+    for target in targets:
+        is_ps = target.suffix == ".ps1"
         text = ""
-        if profile.exists():
+        if target.exists():
             try:
-                text = profile.read_bytes().decode("utf-8-sig")
+                text = target.read_bytes().decode("utf-8-sig")
             except UnicodeDecodeError:
                 # Rewriting a non-UTF-8 profile would corrupt it.
-                console.print(f"[yellow]Skipped[/yellow] {profile} (not UTF-8; edit it by hand)")
+                console.print(f"[yellow]Skipped[/yellow] {target} (not UTF-8; edit it by hand)")
                 continue
         new = _strip_block(text)
         if add:
-            new = (new.rstrip("\n") + "\n\n" if new.strip() else "") + block
+            line = (
+                f"if (Test-Path '{HOOK_PATH}') {{ . '{HOOK_PATH}' }}"
+                if is_ps
+                else f"if [ -f '{sh}' ]; then . '{sh}'; fi"
+            )
+            new = (new.rstrip("\n") + "\n\n" if new.strip() else "") + f"{_BEGIN}\n{line}\n{_END}\n"
         elif new == text:
             continue
-        profile.parent.mkdir(parents=True, exist_ok=True)
-        # BOM so Windows PowerShell 5.1 reads non-ASCII paths correctly.
-        profile.write_bytes(new.encode("utf-8-sig"))
-        console.print(f"[green]{'Installed' if add else 'Removed'}[/green] {profile}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        # BOM so Windows PowerShell 5.1 reads non-ASCII paths correctly; a BOM would break bash.
+        target.write_bytes(new.encode("utf-8-sig" if is_ps else "utf-8"))
+        console.print(f"[green]{'Installed' if add else 'Removed'}[/green] {target}")
 
     if add:
-        console.print("Active in new PowerShell windows. Enable in this window now with:")
-        console.print(f"  . '{HOOK_PATH}'", highlight=False)
-        console.print("[dim]Skip one command: start it with a space. Disable: $env:CODIGEST_NOCAP = 1[/dim]")
+        console.print("Active in new shell windows. Enable in this one now with:")
+        if any(t.suffix == ".ps1" for t in targets):
+            console.print(f"  PowerShell:  . '{HOOK_PATH}'", highlight=False)
+        if any(t.suffix != ".ps1" for t in targets):
+            console.print(f"  bash / zsh:  . '{sh}'", highlight=False)
+        console.print("[dim]Skip one command: start it with a space. Disable: set CODIGEST_NOCAP=1[/dim]")
 
 
 @app.command("install")
-def install() -> None:
-    """Hook PowerShell so every command's output is captured automatically."""
-    _rewrite_profiles(add=True)
+def install(shell: ShellOption = "auto") -> None:
+    """Hook your shells so every command's output is captured automatically."""
+    _rewrite_profiles(add=True, shell=shell)
 
 
 @app.command("uninstall")
-def uninstall() -> None:
-    """Remove the PowerShell capture hook from your profile."""
-    _rewrite_profiles(add=False)
+def uninstall(shell: ShellOption = "auto") -> None:
+    """Remove the capture hook from your shell startup files."""
+    _rewrite_profiles(add=False, shell=shell)

codigest-0.5.0/src/codigest/shell/hook.sh

@@ -0,0 +1,135 @@
+# Codigest terminal capture hook for bash (4+) and zsh. Installed by `cdg term install`.
+#
+# On Enter, the accepted line is rewritten to `__cdg_pre <line>; __cdg_run`.
+# `__cdg_run` is an alias, so the line runs through `eval` in the current
+# shell: `cd`, variables, functions and `$1` behave exactly as typed. Output is
+# teed into a private temp file and handed to `cdg term ingest` in a background
+# process (redaction happens there, before anything is stored).
+#
+# Opt out for one command: start the line with a space.
+# Opt out entirely: export CODIGEST_NOCAP=1
+
+[ -n "${CODIGEST_NOCAP-}" ] && return 0
+case $- in *i*) ;; *) return 0 ;; esac
+if [ -n "${ZSH_VERSION-}" ]; then
+    __cdg_shell=zsh
+    zmodload zsh/datetime 2>/dev/null
+elif [ -n "${BASH_VERSION-}" ] && [ "${BASH_VERSINFO[0]}" -ge 4 ]; then
+    __cdg_shell=bash
+else
+    return 0
+fi
+__cdg_exe=$(command -v cdg 2>/dev/null) || return 0
+
+# Raw output may hold secrets until ingest redacts it: keep it owner-only.
+__cdg_dir=${TMPDIR:-/tmp}/codigest-${UID:-0}
+[ -d "$__cdg_dir" ] || mkdir -m 700 "$__cdg_dir" 2>/dev/null
+{ [ -d "$__cdg_dir" ] && [ -O "$__cdg_dir" ] && [ ! -L "$__cdg_dir" ]; } || return 0
+
+# Denylist heuristic for programs that need a real TTY (editors, pagers,
+# REPLs, ssh). Extend with CODIGEST_CAP_SKIP (an extended regex).
+__cdg_skip='^[[:space:]]*(vim?|nvim|nano|emacs|less|more|man|ssh|htop|btop|top|fzf|lazygit|tmux|screen|claude|codex|wsl|exit|exec|fg|bg)(\.exe)?([[:space:]]|$)'
+__cdg_skip+='|^[[:space:]]*(cdg|codigest)(\.exe)?[[:space:]]+(term|mcp)([[:space:]]|$)'
+__cdg_skip+='|^[[:space:]]*(python3?|py|ipython|node|pwsh|powershell|bash|zsh|sh|fish|cmd)(\.exe)?[[:space:]]*$'
+__cdg_skip+='|^[[:space:]]*git[[:space:]]+(rebase[[:space:]]+-i|add[[:space:]]+-[pi]|mergetool)'
+# A background job would hold the pipe open; a one-line heredoc reads its body later.
+__cdg_skip+='|(^|[^&<>|])&($|[^&>])|(^|[^<])<<([^<]|$)'
+__cdg_commit='^[[:space:]]*git[[:space:]]+commit'
+__cdg_msg='[[:space:]]-[[:alnum:]]*[mF]'
+
+__cdg_now() {
+    if [ -n "${EPOCHREALTIME-}" ]; then __cdg_t=$EPOCHREALTIME
+    else printf -v __cdg_t '%(%s)T' -1; fi
+}
+
+__cdg_wants() {
+    [ -z "${CODIGEST_NOCAP-}" ] || return 1
+    case $1 in '' | [[:space:]]*) return 1 ;; esac
+    [[ $1 =~ $__cdg_skip ]] && return 1
+    [[ -n ${CODIGEST_CAP_SKIP-} && $1 =~ $CODIGEST_CAP_SKIP ]] && return 1
+    [[ $1 =~ $__cdg_commit && ! $1 =~ $__cdg_msg ]] && return 1
+    # Quoting the line would stop `!!`-style history expansion.
+    if [ "$__cdg_shell" = zsh ]; then [[ -o banghist && $1 == *!* ]] && return 1
+    else [[ $- == *H* && $1 == *!* ]] && return 1; fi
+    # Incomplete input (open loop, quote...) goes through untouched to the continuation prompt.
+    if [ "$__cdg_shell" = zsh ]; then zsh -f -n -c "$1" 2>/dev/null
+    else BASH_ENV= "$BASH" -n -c "$1" 2>/dev/null; fi
+}
+
+__cdg_pre() {
+    local s=$?
+    __cdg_cmd=$1
+    __cdg_file=$__cdg_dir/$$.$RANDOM$RANDOM
+    printf '%s\0' "$1" >| "$__cdg_file"  # ingest reads the command from here, output follows
+    __cdg_unbuf=${PYTHONUNBUFFERED-}
+    __cdg_unbuf_set=${PYTHONUNBUFFERED+1}
+    export PYTHONUNBUFFERED=1  # piped Python would otherwise block-buffer live output
+    __cdg_bg=$!
+    __cdg_now; __cdg_t0=$__cdg_t
+    __cdg_busy=1
+    return $s
+}
+
+__cdg_post() {
+    local s=$?
+    [ -n "${__cdg_busy-}" ] || return $s
+    __cdg_busy=
+    __cdg_now
+    # bash does not wait for process substitutions; zsh does for a brace group.
+    [ "$__cdg_shell" = bash ] && [ "$!" != "$__cdg_bg" ] && wait "$!" 2>/dev/null
+    if [ -n "$__cdg_unbuf_set" ]; then export PYTHONUNBUFFERED=$__cdg_unbuf; else unset PYTHONUNBUFFERED; fi
+    ( "$__cdg_exe" term ingest --file="$__cdg_file" --exit-code="$s" --cwd="$PWD" \
+        --shell="$__cdg_shell" --start="$__cdg_t0" --end="$__cdg_t" </dev/null >/dev/null 2>&1 & )
+    return $s
+}
+
+# tee ignores Ctrl+C so it keeps recording what the interrupted program prints last.
+alias __cdg_run='{ eval "$__cdg_cmd"; } > >(trap "" INT; exec tee -a -- "$__cdg_file") 2>&1; __cdg_post'
+
+if [ "$__cdg_shell" = zsh ]; then
+    __cdg_accept() {
+        if [[ -z $PREBUFFER ]] && __cdg_wants "$BUFFER"; then
+            print -sr -- "$BUFFER"
+            BUFFER="__cdg_pre ${(qq)BUFFER}; __cdg_run"
+        fi
+        zle __cdg_orig_accept
+    }
+    # Keep the wrapper out of history; the original line was added above.
+    __cdg_addhistory() { [[ $1 != '__cdg_pre '* ]]; }
+    if [ -z "${__cdg_hooked-}" ]; then
+        __cdg_hooked=1
+        zle -A accept-line __cdg_orig_accept
+        zle -N accept-line __cdg_accept
+        zshaddhistory_functions=(__cdg_addhistory $zshaddhistory_functions)
+        # Ctrl+C skips the trailing __cdg_post; finish the entry before the prompt.
+        precmd_functions=(__cdg_post $precmd_functions)
+    fi
+else
+    __cdg_rewrite() {
+        if [ -z "${__cdg_cont-}" ] && __cdg_wants "$READLINE_LINE"; then
+            history -s -- "$READLINE_LINE"
+            printf -v READLINE_LINE '__cdg_pre %q; __cdg_run' "$READLINE_LINE"
+        fi
+        # Any further Enter before the next prompt is a continuation line.
+        __cdg_cont=1
+    }
+    __cdg_prompt() {
+        __cdg_post
+        local s=$?
+        __cdg_cont=
+        return $s
+    }
+    if [ -z "${__cdg_hooked-}" ]; then
+        __cdg_hooked=1
+        HISTIGNORE="__cdg_pre *${HISTIGNORE:+:$HISTIGNORE}"
+        PROMPT_COMMAND="__cdg_prompt${PROMPT_COMMAND:+;$PROMPT_COMMAND}"
+        for __cdg_m in emacs vi-insert vi-command; do
+            bind -m "$__cdg_m" -x '"\C-x\C-c": __cdg_rewrite'
+            bind -m "$__cdg_m" '"\C-m": "\C-x\C-c\C-j"'
+        done
+        unset __cdg_m
+    fi
+fi
+
+# Lets `cdg term` tell whether this shell is hooked.
+export CODIGEST_HOOK=1

codigest-0.5.0/tests/test_term_install.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from codigest.commands import term
+from codigest.core import termstore
+
+
+def test_ingest_options_and_output_file(tmp_path, monkeypatch):
+    monkeypatch.setenv("CODIGEST_HOME", str(tmp_path / "home"))
+    out = tmp_path / "out"
+    out.write_bytes("echo 'a' \"b\" $HOME *.py | y\0".encode() + 'say "hi" — ünïcode\n'.encode())
+    result = CliRunner().invoke(term.app, [
+        "ingest", f"--file={out}", "--exit-code=3", f"--cwd={tmp_path}",
+        "--shell=bash", "--start=1700000000,25", "--end=1700000001.5",
+    ])
+    assert result.exit_code == 0, result.output
+    [entry] = termstore.load_entries()
+    assert entry.command == "echo 'a' \"b\" $HOME *.py | y"
+    assert entry.output == 'say "hi" — ünïcode'
+    assert (entry.exit_code, entry.shell, entry.duration_ms) == (3, "bash", 1250)
+    assert entry.cwd == str(tmp_path) and entry.started_at[:2] == "20" and entry.started_at[-6] in "+-"
+    assert not out.exists()
+
+
+def test_ingest_stdin_json_still_works(tmp_path, monkeypatch):
+    monkeypatch.setenv("CODIGEST_HOME", str(tmp_path))
+    result = CliRunner().invoke(term.app, ["ingest"], input='{"command": "ls", "output": "x", "exit_code": 0}')
+    assert result.exit_code == 0
+    assert [e.command for e in termstore.load_entries()] == ["ls"]
+
+
+def test_install_uninstall_rc_files(tmp_path, monkeypatch):
+    monkeypatch.setattr(term.Path, "home", lambda: tmp_path)
+    monkeypatch.delenv("ZDOTDIR", raising=False)
+    monkeypatch.setattr(term, "_powershell_profiles", lambda: [])
+    monkeypatch.setattr(term.shutil, "which", lambda name: "/bin/bash" if name == "bash" else None)
+    bashrc, zshrc = tmp_path / ".bashrc", tmp_path / ".zshrc"
+    bashrc.write_bytes(b"alias g=git\n")
+    runner = CliRunner()
+
+    assert runner.invoke(term.app, ["install"]).exit_code == 0  # auto: bash only
+    assert runner.invoke(term.app, ["install"]).exit_code == 0  # idempotent
+    text = bashrc.read_bytes().decode()
+    assert text.startswith("alias g=git\n\n" + term._BEGIN) and text.count(term._BEGIN) == 1
+    assert f". '{term._posix(term.SH_HOOK_PATH)}'" in text and "\r" not in text
+    assert not text.startswith("\ufeff") and not zshrc.exists()
+
+    assert runner.invoke(term.app, ["install", "--shell", "zsh"]).exit_code == 0
+    assert term._BEGIN in zshrc.read_text()
+    assert runner.invoke(term.app, ["install", "--shell", "fish"]).exit_code != 0
+
+    assert runner.invoke(term.app, ["uninstall"]).exit_code == 0  # auto removes everywhere
+    assert bashrc.read_bytes() == b"alias g=git\n"
+    assert zshrc.read_text() == ""
+
+
+def test_posix_hook_path():
+    assert term._posix(Path("C:/Users/me/hook.sh")).endswith("/Users/me/hook.sh")
+    if Path("C:/x").drive:
+        assert term._posix(Path(r"C:\Users\me\hook.sh")) == "/c/Users/me/hook.sh"

{codigest-0.4.3 → codigest-0.5.0}/uv.lock

@@ -1,6 +1,6 @@
 version = 1
 revision = 3
-requires-python = ">=3.15"
+requires-python = ">=3.15.0"
 
 [[package]]
 name = "click"
@@ -16,7 +16,7 @@ wheels = [
 
 [[package]]
 name = "codigest"
-version = "0.4.3"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "loguru" },