keeplog 0.1.0__tar.gz

keeplog-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,20 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: python -m pip install build twine
+      - run: python -m build
+      - run: python -m twine upload dist/*
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}

keeplog-0.1.0/.github/workflows/python-app.yml

@@ -0,0 +1,40 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python application
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install flake8 pytest
+        python -m pip install -e .
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        python -m keeplog init
+        python -m keeplog status

keeplog-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+*.egg
+.env
+.venv
+venv/
+*.sqlite
+*.db
+MEMORY.md
+AGENTS.md

keeplog-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rathina Devan E M
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

keeplog-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: keeplog
+Version: 0.1.0
+Summary: Terminal session logger with full-text search
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# keeplog
+
+Terminal session logger with full-text search.

keeplog-0.1.0/README.md

@@ -0,0 +1,3 @@
+# keeplog
+
+Terminal session logger with full-text search.

keeplog-0.1.0/install.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO="rathinadev/keeplog"
+
+echo "==> Installing keeplog..."
+
+if ! command -v python3 &>/dev/null; then
+    echo "ERROR: python3 is required. Install it first:"
+    echo "  macOS: brew install python"
+    echo "  Linux: apt install python3 python3-pip"
+    exit 1
+fi
+
+if ! command -v pip3 &>/dev/null && ! python3 -m pip --version &>/dev/null; then
+    echo "ERROR: pip is required."
+    exit 1
+fi
+
+python3 -m pip install --quiet --upgrade keeplog 2>/dev/null || {
+    echo "==> Installing from source..."
+    TMPDIR=$(mktemp -d)
+    cd "$TMPDIR"
+    curl -fsSL "https://github.com/$REPO/archive/main.tar.gz" | tar xz --strip=1
+    python3 -m pip install --quiet -e .
+    cd /
+    rm -rf "$TMPDIR"
+}
+
+echo "==> Initializing database..."
+python3 -m keeplog init
+
+echo "==> Adding to shell rc..."
+python3 -m keeplog setup
+
+echo ""
+echo "Done! Restart your terminal or run: source ~/.zshrc"

keeplog-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "keeplog"
+version = "0.1.0"
+description = "Terminal session logger with full-text search"
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = []
+
+[project.scripts]
+keeplog = "keeplog.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/keeplog"]

keeplog-0.1.0/src/keeplog/__main__.py

@@ -0,0 +1,3 @@
+from keeplog.cli import main
+
+main()

keeplog-0.1.0/src/keeplog/capture.py

@@ -0,0 +1,240 @@
+import os
+import pty
+import select
+import signal
+import struct
+import fcntl
+import sys
+import termios
+import tty
+import time
+import tempfile
+import shutil
+
+from keeplog.db import create_session, end_session, save_command
+
+
+def _find_shell() -> str:
+    return os.environ.get("SHELL", "/bin/bash")
+
+
+def _shell_name(path: str) -> str:
+    return os.path.basename(path).lower()
+
+
+def _hooks_dir() -> str:
+    return os.path.join(os.path.dirname(__file__), "hooks")
+
+
+def _build_rc(shell_path: str):
+    name = _shell_name(shell_path)
+    hook_path = os.path.join(_hooks_dir(), f"{name}.sh")
+    user_rc = os.path.expanduser(f"~/.{name}rc")
+
+    lines = ["export __KEEPLOG_READY=0"]
+    if os.path.exists(user_rc):
+        lines.append(f"source {user_rc}")
+    lines.append(f"source {hook_path}")
+    lines.append("__KEEPLOG_READY=1")
+
+    fd, path = tempfile.mkstemp(prefix=f"keeplog_{name}_", suffix=".sh", text=True)
+    with os.fdopen(fd, "w") as f:
+        f.write("\n".join(lines) + "\n")
+    return path
+
+
+def _build_zsh_zdotdir():
+    hook_path = os.path.join(_hooks_dir(), "zsh.sh")
+    user_zshrc = os.path.expanduser("~/.zshrc")
+
+    zdotdir = tempfile.mkdtemp(prefix="keeplog_zsh_")
+    zshrc_path = os.path.join(zdotdir, ".zshrc")
+    with open(zshrc_path, "w") as f:
+        f.write("export __KEEPLOG_READY=0\n")
+        if os.path.exists(user_zshrc):
+            f.write(f"source {user_zshrc}\n")
+        f.write(f"source {hook_path}\n")
+        f.write("__KEEPLOG_READY=1\n")
+    return zdotdir
+
+
+def _setwinsize(fd, rows, cols):
+    s = struct.pack("HHHH", rows, cols, 0, 0)
+    fcntl.ioctl(fd, termios.TIOCSWINSZ, s)
+
+
+def _get_term_size():
+    s = struct.pack("HHHH", 0, 0, 0, 0)
+    try:
+        result = fcntl.ioctl(sys.stdin.fileno(), termios.TIOCGWINSZ, s)
+        rows, cols = struct.unpack("HHHH", result)[:2]
+        return rows or 24, cols or 80
+    except OSError:
+        return 24, 80
+
+
+def _handle_sigwinch(master_fd):
+    rows, cols = _get_term_size()
+    _setwinsize(master_fd, rows, cols)
+
+
+def record_session(mode: str = "full"):
+    if not sys.stdin.isatty():
+        print("keeplog record requires a terminal. Run this directly in your shell, not via pipe/script.")
+        return
+
+    shell = _find_shell()
+    shell_bin = _shell_name(shell)
+
+    ctrl_r, ctrl_w = os.pipe()
+    os.set_inheritable(ctrl_w, True)
+
+    session_id = create_session()
+    rc_path = None
+    zdotdir = None
+
+    if shell_bin == "zsh":
+        zdotdir = _build_zsh_zdotdir()
+    else:
+        rc_path = _build_rc(shell)
+
+    pid, master_fd = pty.fork()
+
+    if pid == 0:
+        os.environ["KEEPLOG_CTRL_FD"] = str(ctrl_w)
+        os.environ["KEEPLOG_SESSION_ID"] = str(session_id)
+        os.environ["KEEPLOG_MODE"] = mode
+        os.environ["KEEPLOG_ACTIVE"] = "1"
+        os.environ["SHELL_SESSIONS_DISABLE"] = "1"
+        os.close(ctrl_r)
+
+        if shell_bin == "zsh":
+            os.environ["ZDOTDIR"] = zdotdir
+            os.execle(shell, shell, "-i", os.environ)
+        else:
+            os.execle(shell, shell, "--rcfile", rc_path, os.environ)
+        os._exit(1)
+
+    os.close(ctrl_w)
+
+    rows, cols = _get_term_size()
+    _setwinsize(master_fd, rows, cols)
+
+    def winch(_sig, _frame):
+        _setwinsize(master_fd, *_get_term_size())
+
+    signal.signal(signal.SIGWINCH, winch)
+
+    old_term = termios.tcgetattr(sys.stdin.fileno())
+    try:
+        tty.setraw(sys.stdin.fileno())
+
+        output_buf = bytearray()
+        seq = 0
+        current_cmd = None
+        current_cwd = ""
+        current_start = 0.0
+        fds = [master_fd, sys.stdin, ctrl_r]
+
+        while True:
+            try:
+                r, _w, _e = select.select(fds, [], [])
+            except InterruptedError:
+                continue
+
+            if master_fd in r:
+                try:
+                    data = os.read(master_fd, 65536)
+                except OSError:
+                    break
+                if not data:
+                    break
+                output_buf.extend(data)
+                try:
+                    sys.stdout.buffer.write(data)
+                    sys.stdout.buffer.flush()
+                except OSError:
+                    pass
+
+            if sys.stdin in r:
+                try:
+                    data = os.read(sys.stdin.fileno(), 65536)
+                except OSError:
+                    break
+                if not data:
+                    break
+                try:
+                    os.write(master_fd, data)
+                except OSError:
+                    pass
+
+            if ctrl_r in r:
+                try:
+                    raw = os.read(ctrl_r, 4096)
+                except OSError:
+                    break
+                if not raw:
+                    break
+                for line in raw.decode("utf-8", errors="replace").split("\n"):
+                    line = line.strip()
+                    if not line:
+                        continue
+                    if line.startswith("C:"):
+                        _flush_cmd(
+                            session_id, seq, current_cmd,
+                            current_cwd, mode, output_buf,
+                            current_start,
+                        )
+                        seq += 1
+                        current_cmd = line[2:]
+                        current_cwd = os.getcwd()
+                        current_start = time.time()
+                        output_buf = bytearray()
+                    elif line.startswith("E:") and current_cmd is not None:
+                        try:
+                            ec = int(line[2:])
+                        except ValueError:
+                            ec = -1
+                        _flush_cmd(
+                            session_id, seq, current_cmd,
+                            current_cwd, mode, output_buf,
+                            current_start, ec,
+                        )
+                        seq += 1
+                        current_cmd = None
+                        output_buf = bytearray()
+
+    finally:
+        termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, old_term)
+        try:
+            if rc_path:
+                os.remove(rc_path)
+            if zdotdir:
+                shutil.rmtree(zdotdir, ignore_errors=True)
+        except OSError:
+            pass
+        end_session(session_id)
+
+
+def _strip_ansi(text: str) -> str:
+    import re
+    ansi_re = re.compile(
+        r"\x1b\[[0-9;?]*[a-zA-Z]"
+        r"|\x1b\].*?\x07"
+        r"|\x1b\([0-9a-zA-Z]"
+    )
+    return ansi_re.sub("", text)
+
+
+def _flush_cmd(session_id, seq, command, cwd, mode, output_buf, start_time, exit_code=None):
+    if exit_code is None:
+        exit_code = -1
+    cmd = (command or "").strip()
+    if not cmd:
+        return
+    duration_ms = int((time.time() - start_time) * 1000)
+    output = _strip_ansi(output_buf.decode("utf-8", errors="replace"))
+    save_command(
+        session_id, seq, cmd, cwd or os.getcwd(),
+        exit_code, duration_ms, mode, output if mode == "full" else None,
+    )

keeplog-0.1.0/src/keeplog/cli.py

@@ -0,0 +1,121 @@
+import json
+import sys
+import signal
+
+from keeplog.db import (
+    init_db, search as db_search, list_recent, get_command,
+    get_stats, get_last_session, export_all, clear_old,
+)
+from keeplog.capture import record_session
+from keeplog.install import setup_hook, remove_hook
+from keeplog.search import search_interactive
+from keeplog.config import load as load_config, save as save_config, get as get_config
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: keeplog <command>")
+        print("Commands:")
+        print("  record              Start recording session")
+        print("  setup               Add auto-start hook to shell rc")
+        print("  remove              Remove auto-start hook from shell rc")
+        print("  search <query>      Interactive fzf search")
+        print("  recent              Show recent commands")
+        print("  get <id>            Show full command details")
+        print("  status              Show stats")
+        print("  last                Show last session")
+        print("  export              Export all data as JSON")
+        print("  clear <days>        Clear old data (default 30 days)")
+        print("  config [key val]    Get/set configuration")
+        print("  init                Initialize database")
+        return
+
+    cmd = sys.argv[1]
+
+    if cmd == "init":
+        init_db()
+        print("Database initialized")
+
+    elif cmd == "record":
+        signal.signal(signal.SIGINT, signal.SIG_DFL)
+        mode = sys.argv[2] if len(sys.argv) > 2 else get_config("mode")
+        from keeplog.db import clear_old
+        clear_old(get_config("retention_days"))
+        record_session(mode)
+
+    elif cmd == "search":
+        if len(sys.argv) < 3:
+            print("Usage: keeplog search <query>")
+            return
+        search_interactive(sys.argv[2])
+
+    elif cmd == "recent":
+        results = list_recent()
+        for r in results:
+            print(f"  [{r['id']}] {r['command']}")
+
+    elif cmd == "get":
+        if len(sys.argv) < 3:
+            print("Usage: keeplog get <id>")
+            return
+        cmd_data = get_command(int(sys.argv[2]))
+        if cmd_data:
+            print(f"Command: {cmd_data['command']}")
+            print(f"CWD: {cmd_data['cwd']}")
+            print(f"Exit: {cmd_data['exit_code']}")
+            print(f"Time: {cmd_data['timestamp']}")
+            if cmd_data.get("output"):
+                print(f"Output:\n{cmd_data['output']}")
+        else:
+            print("Not found")
+
+    elif cmd == "status":
+        s = get_stats()
+        print(f"Commands recorded: {s['commands']}")
+        print(f"Sessions: {s['sessions']}")
+        print(f"Storage: {_fmt_bytes(s['storage_bytes'])}")
+        print(f"Last command: {s['last_command'] or 'N/A'}")
+
+    elif cmd == "last":
+        cmds = get_last_session()
+        if not cmds:
+            print("No sessions yet")
+            return
+        for c in cmds:
+            print(f"[{c['sequence']}] {c['command']}  (exit: {c['exit_code']})")
+
+    elif cmd == "export":
+        data = export_all()
+        json.dump(data, sys.stdout, indent=2, default=str)
+        print()
+
+    elif cmd == "clear":
+        days = int(sys.argv[2]) if len(sys.argv) > 2 else 30
+        clear_old(days)
+        print(f"Cleared data older than {days} days")
+
+    elif cmd == "setup":
+        setup_hook()
+
+    elif cmd == "remove":
+        remove_hook()
+
+    elif cmd == "config":
+        cfg = load_config()
+        if len(sys.argv) >= 4:
+            save_config({sys.argv[2]: sys.argv[3]})
+            print(f"Set {sys.argv[2]} = {sys.argv[3]}")
+        else:
+            for k, v in cfg.items():
+                print(f"  {k} = {v}")
+
+    else:
+        print(f"Unknown command: {cmd}")
+
+
+def _fmt_bytes(b: int) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if b < 1024:
+            return f"{b:.1f} {unit}"
+        b /= 1024
+    return f"{b:.1f} TB"

keeplog-0.1.0/src/keeplog/config.py

@@ -0,0 +1,49 @@
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def _config_dir() -> Path:
+    if sys.platform == "darwin":
+        base = Path.home() / "Library" / "Application Support"
+    else:
+        base = Path.home() / ".config"
+    return base / "keeplog"
+
+
+CONFIG_PATH = _config_dir() / "config.json"
+
+_DEFAULTS = {
+    "mode": "full",
+    "retention_days": 30,
+}
+
+
+def load() -> dict:
+    if not CONFIG_PATH.exists():
+        return dict(_DEFAULTS)
+    try:
+        with open(CONFIG_PATH) as f:
+            return {**_DEFAULTS, **json.load(f)}
+    except (json.JSONDecodeError, OSError):
+        return dict(_DEFAULTS)
+
+
+def save(cfg: dict):
+    _config_dir().mkdir(parents=True, exist_ok=True)
+    merged = {**_DEFAULTS, **cfg}
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(merged, f, indent=2)
+        f.write("\n")
+
+
+def get(key: str) -> Any:
+    return load().get(key, _DEFAULTS.get(key))
+
+
+def set_key(key: str, value: Any):
+    cfg = load()
+    cfg[key] = value
+    save(cfg)

keeplog-0.1.0/src/keeplog/db.py

@@ -0,0 +1,253 @@
+import sqlite3
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+def _data_dir() -> Path:
+    if sys.platform == "darwin":
+        base = Path.home() / "Library" / "Application Support"
+    else:
+        base = Path.home() / ".local" / "share"
+    return base / "keeplog"
+
+
+DB_PATH = _data_dir() / "logs.db"
+
+
+def _get_conn() -> sqlite3.Connection:
+    _data_dir().mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    return conn
+
+
+def _db_exists() -> bool:
+    return DB_PATH.exists()
+
+
+def ensure_db():
+    if not _db_exists():
+        init_db()
+
+
+def init_db():
+    conn = _get_conn()
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS sessions (
+            id INTEGER PRIMARY KEY,
+            started_at TEXT NOT NULL DEFAULT (datetime('now')),
+            ended_at TEXT,
+            hostname TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS commands (
+            id INTEGER PRIMARY KEY,
+            session_id INTEGER NOT NULL,
+            sequence INTEGER NOT NULL,
+            command TEXT NOT NULL,
+            cwd TEXT,
+            exit_code INTEGER,
+            timestamp TEXT NOT NULL DEFAULT (datetime('now')),
+            duration_ms INTEGER,
+            mode TEXT NOT NULL DEFAULT 'full',
+            FOREIGN KEY (session_id) REFERENCES sessions(id)
+        );
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS commands_fts USING fts5(
+            command, cwd, content='commands', content_rowid='id'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS commands_ai AFTER INSERT ON commands BEGIN
+            INSERT INTO commands_fts(rowid, command, cwd) VALUES (new.id, new.command, new.cwd);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS commands_ad AFTER DELETE ON commands BEGIN
+            INSERT INTO commands_fts(commands_fts, rowid, command, cwd) VALUES('delete', old.id, old.command, old.cwd);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS commands_au AFTER UPDATE ON commands BEGIN
+            INSERT INTO commands_fts(commands_fts, rowid, command, cwd) VALUES('delete', old.id, old.command, old.cwd);
+            INSERT INTO commands_fts(rowid, command, cwd) VALUES (new.id, new.command, new.cwd);
+        END;
+
+        CREATE TABLE IF NOT EXISTS output (
+            command_id INTEGER PRIMARY KEY,
+            content TEXT,
+            FOREIGN KEY (command_id) REFERENCES commands(id)
+        );
+    """)
+    conn.commit()
+    conn.close()
+
+
+def create_session(hostname: str = "") -> int:
+    ensure_db()
+    conn = _get_conn()
+    cur = conn.execute(
+        "INSERT INTO sessions (hostname) VALUES (?)", (hostname or "",)
+    )
+    session_id = cur.lastrowid
+    conn.commit()
+    conn.close()
+    return session_id
+
+
+def end_session(session_id: int):
+    conn = _get_conn()
+    conn.execute(
+        "UPDATE sessions SET ended_at = datetime('now') WHERE id = ?",
+        (session_id,)
+    )
+    conn.commit()
+    conn.close()
+
+
+def save_command(
+    session_id: int,
+    sequence: int,
+    command: str,
+    cwd: str,
+    exit_code: int,
+    duration_ms: int = 0,
+    mode: str = "full",
+    output_content: Optional[str] = None,
+) -> int:
+    conn = _get_conn()
+    cur = conn.execute(
+        """INSERT INTO commands (session_id, sequence, command, cwd, exit_code, duration_ms, mode)
+           VALUES (?, ?, ?, ?, ?, ?, ?)""",
+        (session_id, sequence, command, cwd, exit_code, duration_ms, mode),
+    )
+    cmd_id = cur.lastrowid
+    if output_content is not None and mode == "full":
+        conn.execute(
+            "INSERT INTO output (command_id, content) VALUES (?, ?)",
+            (cmd_id, output_content),
+        )
+    conn.commit()
+    conn.close()
+    return cmd_id
+
+
+def search(query: str, limit: int = 50) -> list:
+    if not _db_exists():
+        return []
+    conn = _get_conn()
+    rows = conn.execute(
+        """SELECT c.id, c.command, c.cwd, c.exit_code, c.timestamp, c.duration_ms, c.mode,
+                  substr(o.content, 1, 200) AS output_preview
+           FROM commands_fts f
+           JOIN commands c ON c.id = f.rowid
+           LEFT JOIN output o ON o.command_id = c.id
+           WHERE commands_fts MATCH ?
+           ORDER BY c.timestamp DESC
+           LIMIT ?""",
+        (query, limit),
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def list_recent(limit: int = 20) -> list:
+    if not _db_exists():
+        return []
+    conn = _get_conn()
+    rows = conn.execute(
+        """SELECT c.id, c.command, c.cwd, c.exit_code, c.timestamp, c.duration_ms, c.mode,
+                  substr(o.content, 1, 200) AS output_preview
+           FROM commands c
+           LEFT JOIN output o ON o.command_id = c.id
+           ORDER BY c.timestamp DESC
+           LIMIT ?""",
+        (limit,),
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def get_command(command_id: int) -> Optional[dict]:
+    if not _db_exists():
+        return None
+    conn = _get_conn()
+    row = conn.execute(
+        """SELECT c.*, o.content AS output
+           FROM commands c
+           LEFT JOIN output o ON o.command_id = c.id
+           WHERE c.id = ?""",
+        (command_id,),
+    ).fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+
+def get_stats() -> dict:
+    result = {"commands": 0, "sessions": 0, "storage_bytes": 0, "last_command": None}
+    if not _db_exists():
+        return result
+    conn = _get_conn()
+    cur = conn.execute("SELECT COUNT(*) FROM commands")
+    result["commands"] = cur.fetchone()[0]
+    cur = conn.execute("SELECT COUNT(*) FROM sessions")
+    result["sessions"] = cur.fetchone()[0]
+    cur = conn.execute("SELECT SUM(LENGTH(content)) FROM output")
+    result["storage_bytes"] = cur.fetchone()[0] or 0
+    cur = conn.execute(
+        "SELECT timestamp FROM commands ORDER BY timestamp DESC LIMIT 1"
+    )
+    row = cur.fetchone()
+    result["last_command"] = row[0] if row else None
+    conn.close()
+    return result
+
+
+def get_last_session() -> Optional[list]:
+    if not _db_exists():
+        return None
+    conn = _get_conn()
+    row = conn.execute(
+        """SELECT c.*, o.content AS output
+           FROM commands c
+           LEFT JOIN output o ON o.command_id = c.id
+           WHERE c.session_id = (SELECT id FROM sessions ORDER BY id DESC LIMIT 1)
+           ORDER BY c.sequence ASC"""
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in row] if row else None
+
+
+def export_all() -> list:
+    if not _db_exists():
+        return []
+    conn = _get_conn()
+    rows = conn.execute(
+        """SELECT c.*, o.content AS output
+           FROM commands c
+           LEFT JOIN output o ON o.command_id = c.id
+           ORDER BY c.timestamp ASC"""
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def clear_old(before_days: int = 30):
+    if not _db_exists():
+        return
+    conn = _get_conn()
+    conn.execute(
+        """DELETE FROM output WHERE command_id IN (
+            SELECT id FROM commands WHERE timestamp < datetime('now', ?)
+        )""",
+        (f"-{before_days} days",),
+    )
+    conn.execute(
+        "DELETE FROM commands WHERE timestamp < datetime('now', ?)",
+        (f"-{before_days} days",),
+    )
+    conn.execute(
+        "DELETE FROM sessions WHERE id NOT IN (SELECT DISTINCT session_id FROM commands)"
+    )
+    conn.commit()
+    conn.close()

keeplog-0.1.0/src/keeplog/hooks/bash.sh

@@ -0,0 +1,23 @@
+__keeplog_preexec() {
+    if [[ "$__KEEPLOG_READY" != "1" ]]; then
+        return
+    fi
+    if [[ -z "$__keeplog_cmd" && -n "$KEEPLOG_CTRL_FD" ]]; then
+        __keeplog_cmd="$BASH_COMMAND"
+        printf 'C:%s\n' "${BASH_COMMAND::1024}" >&$KEEPLOG_CTRL_FD 2>/dev/null
+    fi
+}
+
+__keeplog_precmd() {
+    if [[ "$__KEEPLOG_READY" != "1" ]]; then
+        return
+    fi
+    local ec=$?
+    if [[ -n "$__keeplog_cmd" && -n "$KEEPLOG_CTRL_FD" ]]; then
+        printf 'E:%s\n' "$ec" >&$KEEPLOG_CTRL_FD 2>/dev/null
+        unset __keeplog_cmd
+    fi
+}
+
+trap '__keeplog_preexec' DEBUG
+PROMPT_COMMAND="__keeplog_precmd${PROMPT_COMMAND:+;}$PROMPT_COMMAND"

keeplog-0.1.0/src/keeplog/hooks/zsh.sh

@@ -0,0 +1,24 @@
+_keeplog_preexec() {
+    if [[ "$__KEEPLOG_READY" != "1" ]]; then
+        return
+    fi
+    if [[ -z "$_keeplog_cmd" && -n "$KEEPLOG_CTRL_FD" ]]; then
+        _keeplog_cmd="$1"
+        print -rnu "$KEEPLOG_CTRL_FD" "C:${1::1024}"$'\n'
+    fi
+}
+
+_keeplog_precmd() {
+    if [[ "$__KEEPLOG_READY" != "1" ]]; then
+        return
+    fi
+    local ec=$?
+    if [[ -n "$_keeplog_cmd" && -n "$KEEPLOG_CTRL_FD" ]]; then
+        print -rnu "$KEEPLOG_CTRL_FD" "E:$ec"$'\n'
+        unset _keeplog_cmd
+    fi
+}
+
+autoload -Uz add-zsh-hook
+add-zsh-hook preexec _keeplog_preexec
+add-zsh-hook precmd _keeplog_precmd

keeplog-0.1.0/src/keeplog/install.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import sysconfig
+
+
+def _shell_rc() -> str:
+    shell = os.environ.get("SHELL", "")
+    if "zsh" in shell:
+        return os.path.expanduser("~/.zshrc")
+    return os.path.expanduser("~/.bashrc")
+
+
+def _needs_path_fix() -> tuple:
+    bin_dir = sysconfig.get_path("scripts")
+    path_dirs = os.environ.get("PATH", "").split(":")
+    if bin_dir in path_dirs:
+        return False, None
+    return True, bin_dir
+
+
+_HOOK_LINE = '\nif [[ -z "$KEEPLOG_ACTIVE" ]]; then export KEEPLOG_ACTIVE=1; exec keeplog record; fi\n'
+
+
+def setup_hook():
+    rc = _shell_rc()
+    lines = []
+
+    needs_fix, bin_dir = _needs_path_fix()
+    if needs_fix and bin_dir:
+        path_line = f'\nexport PATH="{bin_dir}:$PATH"'
+        if os.path.exists(rc):
+            with open(rc) as f:
+                content = f.read()
+            if bin_dir not in content:
+                lines.append(path_line)
+        else:
+            lines.append(path_line.strip())
+
+    if os.path.exists(rc):
+        with open(rc) as f:
+            content = f.read()
+        if "KEEPLOG_ACTIVE" in content and not needs_fix:
+            print(f"Already set up in {rc}")
+            return
+        with open(rc, "a") as f:
+            for line in lines:
+                f.write(line + "\n")
+            if "KEEPLOG_ACTIVE" not in content:
+                f.write(_HOOK_LINE)
+    else:
+        with open(rc, "w") as f:
+            for line in lines:
+                f.write(line + "\n")
+            f.write(_HOOK_LINE.strip() + "\n")
+
+    print(f"Setup complete in {rc}")
+    if needs_fix and bin_dir:
+        print(f"  Added {bin_dir} to PATH")
+    print(f"  Auto-start hook added")
+    print("Restart your terminal or run: source " + rc)
+
+
+def remove_hook():
+    rc = _shell_rc()
+    if not os.path.exists(rc):
+        return
+    with open(rc) as f:
+        all_lines = f.readlines()
+    new_lines = [l for l in all_lines if "KEEPLOG_ACTIVE" not in l]
+    if len(new_lines) == len(all_lines):
+        print("Not set up")
+        return
+    with open(rc, "w") as f:
+        f.writelines(new_lines)
+    print(f"Removed keeplog hook from {rc}")

keeplog-0.1.0/src/keeplog/search.py

@@ -0,0 +1,65 @@
+import os
+import subprocess
+import shutil
+
+from keeplog.db import search as db_search, get_command
+
+
+def _has_fzf() -> bool:
+    return shutil.which("fzf") is not None
+
+
+def search_interactive(query: str):
+    results = db_search(query)
+    if not results:
+        print("No results found")
+        return
+
+    if not _has_fzf():
+        _print_results(results)
+        return
+
+    _fzf_pick(results)
+
+
+def _print_results(results: list):
+    for r in results:
+        preview = (r["output_preview"] or "")[:80].replace("\n", " | ")
+        print(f"  [{r['id']}] {r['command']}")
+        if preview:
+            print(f"       {preview}")
+
+
+def _fzf_pick(results: list):
+    lines = [f"{r['id']}  {r['command']}" for r in results]
+
+    preview_cmd = (
+        f"keeplog get {{1}}"
+    )
+
+    proc = subprocess.Popen(
+        [
+            "fzf", "--preview", preview_cmd,
+            "--preview-window", "right:60%:wrap",
+            "--with-nth", "2..",
+            "--reverse",
+        ],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+    out, _err = proc.communicate("\n".join(lines))
+    if not out:
+        return
+
+    cmd_id = out.strip().split(" ")[0]
+    cmd_data = get_command(int(cmd_id))
+    if cmd_data:
+        print(f"Command: {cmd_data['command']}")
+        print(f"CWD: {cmd_data['cwd']}")
+        print(f"Exit: {cmd_data['exit_code']}")
+        print(f"Time: {cmd_data['timestamp']}")
+        if cmd_data.get("output"):
+            print(f"Output:\n{cmd_data['output']}")