codigest 0.4.2__tar.gz → 0.5.0__tar.gz

codigest-0.5.0/.gitattributes

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

codigest-0.5.0/.github/workflows/publish.yml

@@ -0,0 +1,51 @@
+name: Publish
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  pypi:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      id-token: write  # PyPI Trusted Publishing
+      contents: read
+    steps:
+    - uses: actions/checkout@v7
+    - uses: astral-sh/setup-uv@v10.3.0
+    - run: uv python install 3.15
+    - run: uv build
+    - uses: pypa/gh-action-pypi-publish@release/v1
+
+  mcp:
+    name: Publish to the MCP registry
+    needs: pypi
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write  # GitHub OIDC login for io.github.NaNIsaac/*
+      contents: read
+    steps:
+    - uses: actions/checkout@v7
+
+    - name: Set server.json version from the tag
+      run: |
+        VERSION="${GITHUB_REF_NAME#v}"
+        jq --arg v "$VERSION" '.version = $v | .packages[0].version = $v' server.json > server.tmp
+        mv server.tmp server.json
+        # The registry verifies the package on PyPI; wait until the release is visible.
+        for i in $(seq 30); do
+          curl -sf "https://pypi.org/pypi/codigest/$VERSION/json" > /dev/null && exit 0
+          sleep 10
+        done
+        echo "codigest $VERSION not visible on PyPI" && exit 1
+
+    - name: Install mcp-publisher
+      run: curl -sL https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_linux_amd64.tar.gz | tar xz mcp-publisher
+
+    - name: Publish
+      run: |
+        ./mcp-publisher login github-oidc
+        ./mcp-publisher publish

{codigest-0.4.2 → codigest-0.5.0}/.github/workflows/tests.yml

@@ -9,7 +9,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: astral-sh/setup-uv@v5
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.3.0
       - run: uv python install 3.15
       - run: uv run --with pytest pytest -q

{codigest-0.4.2 → 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.2
+version: 0.5.0
 date-released: "2026-10-15"
 keywords:
   - LLM

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codigest
-Version: 0.4.2
+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
@@ -238,6 +241,7 @@ cdg term            # last command
 cdg term -n 3       # last 3 commands
 cdg term -i 2       # only the command from 2 runs ago
 cdg term -f         # last failed command
+cdg term --here -n 3  # last 3 commands run in this project
 
 cdg term path       # where captures are stored (override with CODIGEST_HOME)
 cdg term clear      # delete all captures
@@ -249,7 +253,7 @@ cdg term clear      # delete all captures
 
 | Tool | Returns |
 | --- | --- |
-| `terminal_history` | Recent commands with output and exit code (`count`, `failed`) |
+| `terminal_history` | Recent commands with output and exit code (`count`, `failed`, `here`: only this project, default on) |
 | `scan` | Project snapshot (`targets`, `resolve`, `message`) |
 | `diff` / `semdiff` | Text / structural changes since the anchor |
 | `digest` | Signatures and docstrings only |

{codigest-0.4.2 → 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
@@ -212,6 +215,7 @@ cdg term            # last command
 cdg term -n 3       # last 3 commands
 cdg term -i 2       # only the command from 2 runs ago
 cdg term -f         # last failed command
+cdg term --here -n 3  # last 3 commands run in this project
 
 cdg term path       # where captures are stored (override with CODIGEST_HOME)
 cdg term clear      # delete all captures
@@ -223,7 +227,7 @@ cdg term clear      # delete all captures
 
 | Tool | Returns |
 | --- | --- |
-| `terminal_history` | Recent commands with output and exit code (`count`, `failed`) |
+| `terminal_history` | Recent commands with output and exit code (`count`, `failed`, `here`: only this project, default on) |
 | `scan` | Project snapshot (`targets`, `resolve`, `message`) |
 | `diff` / `semdiff` | Text / structural changes since the anchor |
 | `digest` | Signatures and docstrings only |

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

@@ -1,10 +1,10 @@
 [project]
 name = "codigest"
-version = "0.4.2"
+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.2 → codigest-0.5.0}/server.json

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

{codigest-0.4.2 → codigest-0.5.0}/src/codigest/commands/mcp.py

@@ -15,6 +15,7 @@ exactly what a human would paste, and stdout stays clean for the protocol.
 import json
 import subprocess
 import sys
+from pathlib import Path
 from importlib.metadata import PackageNotFoundError, version
 from typing import Any
 
@@ -40,6 +41,11 @@ TOOLS: list[JSON] = [
             "properties": {
                 "count": {"type": "integer", "minimum": 1, "default": 1, "description": "How many recent commands"},
                 "failed": {"type": "boolean", "default": False, "description": "Only commands that exited non-zero"},
+                "here": {
+                    "type": "boolean",
+                    "default": True,
+                    "description": "Only commands run in the server's working directory (the project) or below",
+                },
             },
         },
     },
@@ -81,12 +87,12 @@ TOOLS: list[JSON] = [
 
 def _terminal_history(args: JSON) -> str:
     count = int(args.get("count", 1))
-    entries = termstore.load_entries()
-    if args.get("failed"):
-        entries = [e for e in entries if e.exit_code not in (None, 0)]
-    if not entries:
+    if not (entries := termstore.load_entries()):
+        # Nothing captured at all: native shell history still names the commands.
         entries, _ = shellhist.read_recent(count)
-    return termstore.render(entries[-count:])
+        return termstore.render(entries)
+    under = Path.cwd() if args.get("here", True) else None
+    return termstore.render(termstore.select(entries, failed=bool(args.get("failed")), under=under)[-count:])
 
 
 def _cli(command: str, args: JSON) -> str:

{codigest-0.4.2 → 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
 
@@ -40,6 +41,11 @@ FailedOption = Annotated[
     typer.Option("-f", "--failed", help="Only commands that exited non-zero"),
 ]
 
+HereOption = Annotated[
+    bool,
+    typer.Option("--here", help="Only commands run in the current directory or below"),
+]
+
 HistoryOnlyOption = Annotated[
     bool,
     typer.Option(
@@ -68,6 +74,7 @@ def handle(
     count: CountOption = 1,
     index: IndexOption = None,
     failed: FailedOption = False,
+    here: HereOption = False,
     history_only: HistoryOnlyOption = False,
     copy: CopyOption = True,
     stdout: StdoutOption = False,
@@ -80,6 +87,7 @@ def handle(
         cdg term -n 3       # the last 3 commands
         cdg term -i 3       # only the command from 3 runs ago
         cdg term -f         # the last failed command
+        cdg term --here -n 3  # the last 3 commands run in this project
     """
     if ctx.invoked_subcommand:
         return
@@ -107,10 +115,11 @@ def handle(
             _diagnose(log)
             raise typer.Exit(code=1)
 
-    if failed:
-        entries = [e for e in entries if e.exit_code not in (None, 0)]
+    if failed or here:
+        entries = termstore.select(entries, failed=failed, under=Path.cwd() if here else None)
         if not entries:
-            log.print("[yellow]No failed commands captured.[/yellow]")
+            what = " and ".join(w for w, on in (("failed", failed), ("in this directory", here)) if on)
+            log.print(f"[yellow]No captured commands match ({what}).[/yellow]")
             raise typer.Exit(code=1)
 
     if index:
@@ -149,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:
@@ -173,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]:
@@ -204,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)
@@ -213,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.4.2 → codigest-0.5.0}/src/codigest/core/termstore.py

@@ -131,6 +131,20 @@ def _truncate(text: str) -> tuple[str, bool]:
 # Read / write
 # --------------------------------------------------------------------------
 
+def _inside(path: str, root: Path) -> bool:
+    path, base = (os.path.normcase(os.path.abspath(p)) for p in (path, root))
+    return path == base or path.startswith(base.rstrip(os.sep) + os.sep)
+
+
+def select(entries: list[Entry], *, failed: bool = False, under: Path | None = None) -> list[Entry]:
+    """Keeps entries that exited non-zero (`failed`) and/or ran inside `under` or below it."""
+    if failed:
+        entries = [e for e in entries if e.exit_code not in (None, 0)]
+    if under is not None:
+        entries = [e for e in entries if e.cwd and _inside(e.cwd, under)]
+    return entries
+
+
 def load_entries() -> list[Entry]:
     """Loads all stored entries, oldest first. Corrupt lines are skipped."""
     path = get_history_path()
@@ -183,7 +197,7 @@ def _trim(path: Path) -> None:
     """Rewrites the log keeping only the most recent MAX_ENTRIES lines."""
     with open(path, "r", encoding="utf-8", errors="replace") as f:
         lines = f.readlines()
-    # ponytail: no file lock. Concurrent hook ingests can drop an entry appended
+    # No file lock: Concurrent hook ingests can drop an entry appended
     # between read and replace; the slack makes rewrites (and that window) rare.
     if len(lines) <= MAX_ENTRIES + _TRIM_SLACK:
         return

{codigest-0.4.2 → codigest-0.5.0}/src/codigest/shell/hook.ps1

@@ -74,7 +74,7 @@ if (-not (Get-Module PSReadLine) -and $Host.Name -eq 'ConsoleHost') {
 }
 if (-not (Get-Module PSReadLine)) { return }
 
-# ponytail: denylist heuristic for programs that need a real TTY (editors, pagers,
+# Denylist heuristic for programs that need a real TTY (editors, pagers,
 # REPLs, ssh). Extend with $env:CODIGEST_CAP_SKIP (a regex) when one slips through.
 $global:__cdgSkip = '^\s*(vim?|nvim|nano|emacs|less|more|ssh|htop|btop|top|fzf|lazygit|claude|codex|wsl|exit)(\.exe)?\b' +
     '|^\s*(cdg|codigest)(\.exe)?\s+(term|mcp)\b' +

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.2 → codigest-0.5.0}/tests/test_termstore.py

@@ -32,6 +32,20 @@ def test_mcp_lists_tools_and_ignores_notifications():
     assert mcp.handle_message({"jsonrpc": "2.0", "id": 2, "method": "nope"})["error"]["code"] == -32601
 
 
+
+def test_select_filters_failed_and_directory(tmp_path):
+    project, other = tmp_path / "proj", tmp_path / "proj-other"
+    entries = [
+        Entry(command="a", exit_code=1, cwd=str(project / "sub")),
+        Entry(command="b", exit_code=0, cwd=str(project)),
+        Entry(command="c", exit_code=2, cwd=str(other)),  # shares the prefix, not the directory
+        Entry(command="d", exit_code=None, cwd=""),
+    ]
+    assert [e.command for e in termstore.select(entries, under=project)] == ["a", "b"]
+    assert [e.command for e in termstore.select(entries, failed=True)] == ["a", "c"]
+    assert [e.command for e in termstore.select(entries, failed=True, under=project)] == ["a"]
+
+
 if __name__ == "__main__":
     test_crlf_output_survives_normalization()
     test_progress_redraw_keeps_last_frame()

{codigest-0.4.2 → 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.2"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "loguru" },

codigest-0.4.2/.github/workflows/publish.yml

@@ -1,73 +0,0 @@
-name: Publish Python distributions to PyPI and GitHub Pages
-
-on:
-  push:
-    tags:
-      - 'v*'  # v0.3.0 태그 푸시 시 배포 실행
-
-jobs:
-  build-n-publish:
-    name: Build and publish Python distributions to PyPI
-    runs-on: ubuntu-latest
-    # v* 태그일 때만 실행
-    if: startsWith(github.ref, 'refs/tags/v')
-    environment: release
-    permissions:
-      id-token: write  # Trusted Publishing을 위한 필수 권한
-      contents: read
-    
-    steps:
-    - uses: actions/checkout@v4
-    
-    # uv 설치 (가장 빠르고 확실한 방법)
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-    
-    # Python 3.14 설정 (uv 이용)
-    - name: Set up Python
-      run: uv python install 3.15
-    
-    # 의존성 설치 및 빌드 (uv build 하나로 해결)
-    - name: Build package
-      run: uv build
-    
-    # PyPI 배포 (기존 형식 유지)
-    - name: Publish package distributions to PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1
-
-  deploy-docs:
-    name: Build and deploy Sphinx docs to GitHub Pages
-    runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/main'
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-
-      - name: Set up Python
-        run: uv python install 3.15
-
-      - name: Install Python and Sphinx dependencies
-        run: |
-          uv pip install --system --upgrade pip
-          if [ -f docs/requirements.txt ]; then uv pip install --system -r docs/requirements.txt; fi
-
-      - name: Build HTML docs with Sphinx
-        run: |
-          if [ -d "docs" ]; then
-            sphinx-build -b html docs/source docs/html
-            touch docs/html/.nojekyll
-          else
-            echo "No docs folder found, skipping build."
-            mkdir -p docs/html
-            touch docs/html/.nojekyll
-          fi
-
-      - name: Deploy to GitHub Pages
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: docs/html