| | #!/usr/bin/env python3 |
| | """ |
| | cc-history — Browse and search Claude Code conversation history. |
| | |
| | Works on Linux, macOS and Windows (Python 3.8+). Reads the JSONL logs that |
| | Claude Code writes to ~/.claude/projects/ (or $CLAUDE_CONFIG_DIR/projects/). |
| | |
| | Examples: |
| | cc-history summary # dashboard for the current project |
| | cc-history list # sessions in the current project, newest first |
| | cc-history list -g # sessions across all projects |
| | cc-history list -p myapp # only projects whose name contains "myapp" |
| | cc-history list -d "yesterday" # natural-language date filters |
| | cc-history list -d "past 3 days" |
| | cc-history list -d "before may 5" |
| | cc-history search "wifi reconnect" # plain-text search |
| | cc-history search "nmcli|wifi" -E # regex search |
| | cc-history search reconect -F # typo-tolerant search |
| | cc-history search wifi -d "last week" -C 3 |
| | cc-history read d31025da # read a session (prefix match OK) |
| | cc-history read # interactive picker |
| | cc-history read --fzf # interactive picker using fzf |
| | cc-history read d31025da --no-tools # hide tool calls |
| | cc-history read d31025da --all-tools # every tool call with full input+output |
| | cc-history read d31025da --ai # just the last assistant message |
| | cc-history read d31025da --git # git commits made in the session |
| | cc-history tools d31025da --summary # tool/MCP call counts |
| | cc-history files d31025da --code # files the session touched |
| | cc-history projects # list all projects |
| | cc-history stats # stats per project |
| | cc-history completions bash|zsh|fish|powershell |
| | """ |
| | |
| | import argparse |
| | import json |
| | import os |
| | import re |
| | import shlex |
| | import shutil |
| | import signal |
| | import subprocess |
| | import sys |
| | import time |
| | from collections import defaultdict |
| | from datetime import datetime |
| | from difflib import SequenceMatcher |
| | from pathlib import Path |
| | |
| | try: |
| | import curses # not in the Windows stdlib; pip install windows-curses provides it |
| | except ImportError: |
| | curses = None |
| | |
| | IS_WINDOWS = os.name == "nt" |
| | |
| | CLAUDE_DIR = Path(os.environ.get("CLAUDE_CONFIG_DIR") or Path.home() / ".claude").expanduser() |
| | PROJECTS_DIR = CLAUDE_DIR / "projects" |
| | INDEX_PATH = CLAUDE_DIR / "cache" / "cc-history-index.json" |
| | |
| | # Claude Code truncates long project dir names and appends a hash |
| | MAX_PROJECT_NAME = 200 |
| | |
| | |
| | def _encode_path(p): |
| | # Claude Code names project dirs by replacing every non-alphanumeric char with '-' |
| | # ("/home/me/my_app" -> "-home-me-my-app", "C:\\Users\\me" -> "C--Users-me") |
| | return re.sub(r"[^A-Za-z0-9]", "-", str(p)) |
| | | | | | | | def _norm_name(name): | | | # Windows paths are case-insensitive | | | return name.lower() if IS_WINDOWS else name | | | | | | | | | def cwd_to_project_dir(): | | | """Map the current working directory to the Claude project directory.""" | | | if not PROJECTS_DIR.is_dir(): | | | return None | | | dirs = {_norm_name(d.name): d for d in PROJECTS_DIR.iterdir() if d.is_dir()} | | | | | | # Walk up parent dirs — Claude stores by project root, which may be a parent |
| | cwd = Path.cwd().resolve() |
| | for p in (cwd, *cwd.parents): |
| | name = _norm_name(_encode_path(p)) |
| | if name in dirs: |
| | return dirs[name] |
| | if len(name) > MAX_PROJECT_NAME: |
| | for dname, d in dirs.items(): |
| | if dname.startswith(name[:MAX_PROJECT_NAME]): |
| | return d | | | return None | | | | | | # ─── Colors ────────────────────────────────────────────────────────────────── | | | |
| | def _supports_color(): |
| | if os.environ.get("NO_COLOR") or not sys.stdout.isatty(): |
| | return False | | | if IS_WINDOWS: | | | # Turn on ANSI escape processing in the Windows console | | | try: | | | import ctypes | | | kernel32 = ctypes.windll.kernel32 |
| | handle = kernel32.GetStdHandle(-11) # STD_OUTPUT_HANDLE |
| | mode = ctypes.c_uint32() |
| | if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)): |
| | return False | | | kernel32.SetConsoleMode(handle, mode.value | 0x0004) # ENABLE_VIRTUAL_TERMINAL_PROCESSING | | | except Exception: | | | return False | | | return True | | | | | | USE_COLOR = _supports_color() | | | | | | def c(code, text): | | | if not USE_COLOR: | | | return text | | | return f"\033[{code}m{text}\033[0m" | | | |
| | def dim(t): return c("2", t) |
| | def bold(t): return c("1", t) |
| | def green(t): return c("32", t) |
| | def cyan(t): return c("36", t) |
| | def yellow(t): return c("33", t) |
| | def magenta(t): return c("35", t) |
| | def red(t): return c("31", t) |
| | def blue(t): return c("34", t) |
| | | | | # ─── JSONL Parsing ─────────────────────────────────────────────────────────── | | | |
| | def iter_jsonl(path): |
| | with open(path, "r", encoding="utf-8", errors="replace") as f: |
| | for line in f: | | | line = line.strip() | | | if not line: | | | continue | | | try: | | | yield json.loads(line) | | | except json.JSONDecodeError: | | | continue | | | | | | | | | def extract_text(content): | | | """Extract plain text from a message content field.""" | | | if isinstance(content, str): | | | return content |
| | if isinstance(content, list): |
| | parts = [] |
| | for item in content: |
| | if isinstance(item, dict): |
| | if item.get("type") == "text": |
| | parts.append(item.get("text", "")) |
| | elif item.get("type") == "tool_use": |
| | parts.append(f"[tool: {item.get('name', '?')}]") |
| | elif item.get("type") == "tool_result": |
| | rc = item.get("content", "") |
| | if isinstance(rc, list): |
| | for r in rc: |
| | if isinstance(r, dict) and r.get("type") == "text": |
| | parts.append(r.get("text", "")) |
| | elif isinstance(rc, str): |
| | parts.append(rc) |
| | return "\n".join(parts) |
| | return "" | | | | | | |
| | def strip_system_tags(text): |
| | """Remove <system-reminder>, <command-name>, etc.""" |
| | text = re.sub(r"<system-reminder>.*?</system-reminder>", "", text, flags=re.DOTALL) |
| | text = re.sub(r"<command-name>.*?</command-name>", "", text, flags=re.DOTALL) |
| | text = re.sub(r"<command-message>.*?</command-message>", "", text, flags=re.DOTALL) |
| | text = re.sub(r"<command-args>.*?</command-args>", "", text, flags=re.DOTALL) |
| | text = re.sub(r"<local-command-caveat>.*?</local-command-caveat>", "", text, flags=re.DOTALL) |
| | text = re.sub(r"<local-command-stdout>.*?</local-command-stdout>", "", text, flags=re.DOTALL) |
| | return text.strip() |
| | | | | | | | def _parse_ts(ts): | | | """Convert a record timestamp (ISO string or epoch s/ms) to epoch seconds.""" | | | if isinstance(ts, (int, float)): | | | return ts / 1000 if ts > 1e12 else ts | | | if isinstance(ts, str): | | | try: | | | return datetime.fromisoformat(ts.replace("Z", "+00:00")).timestamp() | | | except ValueError: | | | return None | | | return None | | | | | | | | | label_cache = {} | | | | | | def project_label(proj_dir): | | | """Readable project name: the session's working dir relative to home. | | | | | | Dir names like '-home-me-my-app' are lossy ('-' could have been '/', '', '.'), | | | so prefer the 'cwd' field recorded in the session logs. | | | """ | | | proj_dir = Path(proj_dir) | | | if proj_dir in _label_cache: | | | return _label_cache[proj_dir] | | | | | | label = proj_dir.name | | | for jsonl_file in sorted(proj_dir.glob("*.jsonl"), key=lambda f: f.stat().st_mtime, reverse=True): | | | cwd = None |
| | for n, record in enumerate(iter_jsonl(jsonl_file)): |
| | cwd = record.get("cwd") |
| | if cwd or n > 50: |
| | break | | | if cwd: | | | p = Path(cwd) | | | try: |
| | label = p.relative_to(Path.home()).as_posix() |
| | label = "~" if label == "." else label |
| | except ValueError: | | | label = p.as_posix() | | | break | | | | | | _label_cache[proj_dir] = label | | | return label | | | | | | | | | # ─── Session Discovery ────────────────────────────────────────────────────── | | | | | | def discover_sessions(project_filter=None, project_dirs=None): | | | """Yield (session_id, project_label, path, title, timestamp) tuples. | | | | | | project_dirs: if set, only scan these specific directories. | | | project_filter: substring filter on project label. | | | """ | | | if not PROJECTS_DIR.exists(): | | | return | | | | | | if project_dirs is not None: | | | dirs_to_scan = [d for d in project_dirs if d.is_dir()] | | | else: | | | dirs_to_scan = sorted(PROJECTS_DIR.iterdir()) | | | | | | for proj_dir in dirs_to_scan: | | | if not proj_dir.is_dir(): | | | continue |
| | label = project_label(proj_dir) |
| | if project_filter and project_filter.lower() not in label.lower(): |
| | continue | | | | | | for jsonl_file in sorted(proj_dir.glob("*.jsonl")): | | | session_id = jsonl_file.stem | | | title = None | | | timestamp = None | | | has_messages = False | | | |
| | for record in iter_jsonl(jsonl_file): |
| | rtype = record.get("type") |
| | if rtype == "ai-title" and record.get("aiTitle"): |
| | title = record["aiTitle"] |
| | if rtype in ("user", "assistant") and "message" in record: | | | has_messages = True | | | # Keep the latest timestamp, so sessions sort by last activity | | | ts = _parse_ts(record.get("timestamp")) | | | if ts is not None: | | | timestamp = ts | | | | | | if not has_messages: | | | continue | | | | | | if timestamp is None: | | | timestamp = jsonl_file.stat().st_mtime | | | | | | if title is None: |
| | for record in iter_jsonl(jsonl_file): |
| | if record.get("type") == "user" and "message" in record: |
| | text = extract_text(record["message"].get("content", "")) |
| | text = strip_system_tags(text).strip() |
| | if text and len(text) > 5: |
| | title = text[:80] |
| | break | | | | | | if title is None: | | | title = "(untitled)" | | | | | | yield session_id, label, str(jsonl_file), title, timestamp | | | | | | | | | def find_session_file(session_prefix): | | | """Find a session file by prefix match.""" |
| | for proj_dir in PROJECTS_DIR.iterdir(): |
| | if not proj_dir.is_dir(): |
| | continue |
| | for jsonl_file in proj_dir.glob("*.jsonl"): |
| | if jsonl_file.stem.startswith(session_prefix): |
| | return jsonl_file | | | return None | | | | | | | | | # ─── Fuzzy Matching ────────────────────────────────────────────────────────── | | | | | | FUZZY_THRESHOLD = 0.75 | | | | | | def fuzzy_line_matches(needle, line): | | | """Return list of (start, end) spans in line that fuzzy-match needle.""" |
| | needle_lower = needle.lower() |
| | n = len(needle_lower) |
| | if n == 0: |
| | return [] |
| | |
| | matches = [] |
| | for m in re.finditer(r"[a-zA-Z0-9_]+", line): |
| | word = m.group().lower() |
| | if len(word) < 2: |
| | continue |
| | ratio = SequenceMatcher(None, needle_lower, word).ratio() |
| | if ratio >= FUZZY_THRESHOLD: |
| | matches.append((m.start(), m.end())) |
| | | | | return matches | | | | | | | | | def fuzzy_text_matches(needle, text): | | | """Check if any line in text fuzzy-matches needle.""" |
| | for line in text.split("\n"): |
| | if fuzzy_line_matches(needle, line): |
| | return True | | | return False | | | | | | | | | def highlight_fuzzy(needle, text): | | | """Highlight fuzzy-matched spans in text.""" |
| | lines = text.split("\n") |
| | result = [] |
| | for line in lines: | | | spans = fuzzy_line_matches(needle, line) | | | if not spans: | | | result.append(line) | | | continue | | | # Build highlighted line from right to left to preserve indices |
| | chars = list(line) |
| | for start, end in sorted(spans, reverse=True): |
| | matched_text = line[start:end] |
| | chars[start:end] = [bold(red(matched_text))] |
| | result.append("".join(chars)) |
| | return "\n".join(result) |
| | | | | | | | # ─── Date Filtering ────────────────────────────────────────────────────────── | | | | | | def parse_date_filter(text): | | | """Parse a natural language date expression into a (start_ts, end_ts) range. | | | | | | Returns (since_ts, until_ts) — either may be None for open-ended. | | | Handles: | | | "two days ago" -> that specific day | | | "may 5" -> that specific day | | | "in the past two days" -> from two days ago to now | | | "last week" -> from one week ago to now | | | "past 3 days" -> from 3 days ago to now | | | "since yesterday" -> from yesterday to now | | | "before may 5" -> everything before may 5 | | | """ | | | try: | | | import dateparser | | | except ImportError: | | | print("dateparser is required for natural-language dates: pip install dateparser", |
| | file=sys.stderr) |
| | sys.exit(1) |
| | |
| | original = text.strip() |
| | lower = original.lower() |
| | | | | before_prefix = re.match(r'^before\s+', lower) | | | if before_prefix: |
| | remainder = original[before_prefix.end():] |
| | parsed = dateparser.parse(remainder) |
| | if not parsed: |
| | print(f"Could not parse date: '{original}'", file=sys.stderr) |
| | sys.exit(1) |
| | return (None, parsed.timestamp()) |
| | | | | # Detect range-style queries: "in the past X", "past X", "since X", "last N days" |
| | range_prefix = re.match( |
| | r'^(in the \|)(past\|since\|previous)\s+', lower |
| | ) | | | # "last N <unit>" is a range, but "last week"/"last month" are dateparser-native | | | last_n_prefix = re.match(r'^(in the |)last\s+(?=\d)', lower) | | | | | | is_range = bool(range_prefix or last_n_prefix) | | | | | | if is_range: | | | prefix = range_prefix or last_n_prefix |
| | remainder = original[prefix.end():] |
| | parsed = dateparser.parse(remainder) or dateparser.parse(remainder + " ago") |
| | if not parsed: |
| | print(f"Could not parse date: '{original}'", file=sys.stderr) |
| | sys.exit(1) |
| | return (parsed.timestamp(), None) |
| | | | | # Try dateparser on the original — handles "last week", "two days ago", "yesterday", "may 5" | | | parsed = dateparser.parse(original) | | | if not parsed: |
| | print(f"Could not parse date: '{original}'", file=sys.stderr) |
| | sys.exit(1) |
| | | | | # Decide: range or exact day? | | | # Phrases like "last week", "last month" are range-like (everything since then) |
| | if re.match(r'^last\s+(week\|month\|year)', lower): |
| | return (parsed.timestamp(), None) |
| | | | | # Otherwise treat as a specific day |
| | day_start = parsed.replace(hour=0, minute=0, second=0, microsecond=0) |
| | day_end = day_start.replace(hour=23, minute=59, second=59) |
| | return (day_start.timestamp(), day_end.timestamp()) |
| | | | | | | | def filter_sessions_by_date(sessions, date_expr): | | | """Filter sessions by a natural language date expression.""" |
| | since_ts, until_ts = parse_date_filter(date_expr) |
| | filtered = [] |
| | for s in sessions: | | | ts = s[4] | | | if ts is None: | | | continue | | | if since_ts is not None and ts < since_ts: | | | continue | | | if until_ts is not None and ts > until_ts: | | | continue | | | filtered.append(s) | | | return filtered | | | | | | | | | # ─── Interactive Picker ─────────────────────────────────────────────────────── | | | | | | def pick_fzf(items, format_fn, preview_cmd=None): | | | """Use fzf to pick from a list. Returns the selected item or None.""" | | | fzf_path = shutil.which("fzf") | | | if not fzf_path: | | | return None | | | |
| | lines = [format_fn(item) for item in items] |
| | input_text = "\n".join(lines) |
| | |
| | cmd = [fzf_path, "--ansi", "--no-sort", "--reverse", |
| | "--header=Type to filter, Enter to select, Esc to cancel"] |
| | if preview_cmd: | | | cmd.extend(["--preview", preview_cmd]) | | | | | | try: |
| | env = dict(os.environ, PYTHONIOENCODING="utf-8") # for the preview subprocess |
| | result = subprocess.run(cmd, input=input_text, capture_output=True, text=True, |
| | encoding="utf-8", errors="replace", env=env) |
| | except (OSError, KeyboardInterrupt): |
| | return None | | | | | | if result.returncode != 0 or not result.stdout.strip(): | | | return None | | | |
| | selected_line = result.stdout.strip() |
| | for i, line in enumerate(lines): |
| | # Strip ANSI for comparison |
| | clean = re.sub(r"\033\[[0-9;]*m", "", line) |
| | clean_sel = re.sub(r"\033\[[0-9;]*m", "", selected_line) |
| | if clean == clean_sel: |
| | return items[i] |
| | return None | | | | | | | | | def pick_curses(items, format_fn): | | | """Pure-Python interactive picker using curses. Returns selected item or None.""" | | | if not items: | | | return None | | | |
| | def _run(stdscr): |
| | curses.curs_set(1) |
| | curses.use_default_colors() |
| | curses.init_pair(1, curses.COLOR_CYAN, -1) |
| | curses.init_pair(2, curses.COLOR_YELLOW, -1) |
| | curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_WHITE) | | | | | | query = "" | | | cursor = 0 | | | selected = None | | | | | | while True: |
| | stdscr.clear() |
| | h, w = stdscr.getmaxyx() |
| | | | | # Filter items | | | if query: |
| | q = query.lower() |
| | filtered = [(i, item) for i, item in enumerate(items) |
| | if q in format_fn(item).lower()] |
| | else: | | | filtered = list(enumerate(items)) | | | | | | cursor = max(0, min(cursor, len(filtered) - 1)) | | | | | | # Header |
| | header = f" cc-history picker ({len(filtered)}/{len(items)}) ─ type to filter, ↑↓ navigate, Enter select, Esc quit" |
| | stdscr.addnstr(0, 0, header, w - 1, curses.A_DIM) |
| | | | | # Query line |
| | prompt = f" > {query}" |
| | stdscr.addnstr(1, 0, prompt, w - 1) |
| | |
| | # Items (starting from row 3) |
| | visible_start = max(0, cursor - (h - 4)) |
| | for row_idx, fi in enumerate(filtered[visible_start:]): |
| | row = row_idx + 3 | | | if row >= h - 1: | | | break | | | | | | idx, item = fi | | | line = format_fn(item) | | | # Strip ANSI codes for curses display | | | clean = re.sub(r"\033[[0-9;]*m", "", line) | | | | | | abs_idx = visible_start + row_idx |
| | if abs_idx == cursor: |
| | stdscr.addnstr(row, 0, f" ▸ {clean}", w - 1, curses.color_pair(3)) |
| | else: | | | stdscr.addnstr(row, 0, f" {clean}", w - 1) | | | | | | # Position cursor at end of query |
| | stdscr.move(1, min(len(prompt), w - 1)) |
| | stdscr.refresh() |
| | | | | try: | | | key = stdscr.get_wch() | | | except curses.error: | | | continue | | | |
| | if isinstance(key, str): |
| | if key == "\x1b": # Esc |
| | return None | | | elif key == "\n" or key == "\r": | | | if filtered: | | | return filtered[cursor][1] | | | return None |
| | elif key in ("\x7f", "\b"): # Backspace |
| | query = query[:-1] |
| | cursor = 0 | | | elif key == "\t": # Tab = select | | | if filtered: | | | return filtered[cursor][1] | | | return None | | | elif len(key) == 1 and key.isprintable(): | | | query += key | | | cursor = 0 |
| | elif isinstance(key, int): |
| | if key in (curses.KEY_ENTER, 459): # 459 = PADENTER in windows-curses |
| | if filtered: | | | return filtered[cursor][1] | | | return None |
| | elif key == curses.KEY_UP: |
| | cursor = max(0, cursor - 1) |
| | elif key == curses.KEY_DOWN: |
| | cursor = min(len(filtered) - 1, cursor + 1) |
| | elif key == curses.KEY_BACKSPACE: |
| | query = query[:-1] |
| | cursor = 0 | | | | | | try: |
| | return curses.wrapper(_run) |
| | except (KeyboardInterrupt, curses.error): |
| | return None | | | | | | | | | def pick_prompt(items, format_fn, page_size=20): | | | """Fallback picker without curses/fzf: numbered list + input().""" | | | query = "" | | | while True: | | | if query: |
| | q = query.lower() |
| | filtered = [item for item in items if q in format_fn(item).lower()] |
| | else: |
| | filtered = list(items) |
| | for i, item in enumerate(filtered[:page_size], 1): |
| | print(f" {cyan(f'{i:3d}')} {format_fn(item)}") |
| | if len(filtered) > page_size: |
| | print(dim(f" ... {len(filtered) - page_size} more, type text to filter")) |
| | try: |
| | answer = input("Number to open, text to filter, empty to quit: ").strip() |
| | except (EOFError, KeyboardInterrupt): |
| | return None | | | if not answer: | | | return None |
| | if answer.isdigit() and 1 <= int(answer) <= min(len(filtered), page_size): |
| | return filtered[int(answer) - 1] |
| | query = answer | | | | | | | | | def interactive_pick_session(sessions, use_fzf=False): | | | """Pick a session interactively. Returns (session_id, label, path, title, ts) or None.""" | | | if not sessions: | | | print("No sessions found.", file=sys.stderr) | | | return None | | | | | | def fmt(s): | | | sid, proj, path, title, ts = s |
| | date_str = datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M") if ts else "????" |
| | return f"{sid[:8]} {date_str} [{proj}] {title}" |
| | | | | if use_fzf and shutil.which("fzf"): | | | # Re-invoke this script for the preview; fzf clips output to the pane | | | argv = [sys.executable, os.path.abspath(file)] | | | if IS_WINDOWS: | | | prog = subprocess.list2cmdline(argv) | | | else: |
| | prog = " ".join(shlex.quote(a) for a in argv) |
| | return pick_fzf(sessions, fmt, preview_cmd=f"{prog} read {{1}} --no-tools") |
| | if use_fzf: | | | print("fzf not found on PATH, using the built-in picker.", file=sys.stderr) | | | if curses is not None and sys.stdin.isatty(): | | | return pick_curses(sessions, fmt) | | | return pick_prompt(sessions, fmt) | | | | | | | | | # ─── Commands ──────────────────────────────────────────────────────────────── | | | | | | def _resolve_project_dirs(args): | | | """Return project_dirs list based on --global flag and cwd.""" | | | if getattr(args, "glob", False) or getattr(args, "project", None): | | | return None # scan all | | | proj_dir = cwd_to_project_dir() | | | if proj_dir: | | | return [proj_dir] | | | return None # cwd not in any project — fall back to all | | | | | | |
| | def cmd_list(args): |
| | project_dirs = _resolve_project_dirs(args) |
| | sessions = list(discover_sessions(project_filter=args.project, project_dirs=project_dirs)) |
| | sessions.sort(key=lambda s: s[4] or 0, reverse=True) |
| | | | | if args.date: | | | sessions = filter_sessions_by_date(sessions, args.date) | | | | | | if args.limit: | | | sessions = sessions[: args.limit] | | | | | | if args.json: | | | out = [] | | | for sid, proj, path, title, ts in sessions: | | | out.append({ | | | "session_id": sid, | | | "project": proj, | | | "title": title, | | | "timestamp": ts, |
| | "date": datetime.fromtimestamp(ts).isoformat() if ts else None, |
| | }) |
| | print(json.dumps(out, indent=2)) |
| | return | | | | | | if not sessions: | | | print("No sessions found.") | | | return | | | | | | if args.pick: | | | picked = interactive_pick_session(sessions, use_fzf=args.fzf) | | | if picked: |
| | args_read = argparse.Namespace(session_id=picked[0], raw=False, no_tools=True) |
| | cmd_read(args_read) |
| | return | | | | | | for sid, proj, path, title, ts in sessions: |
| | date_str = datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M") if ts else "unknown date" |
| | short_id = sid[:8] |
| | print(f" {cyan(short_id)} {dim(date_str)} {dim('[' + proj + ']')} {title}") |
| | | | | | | | def cmd_search(args): | | | use_regex = args.regex | | | use_fuzzy = args.fuzzy | | | if use_regex: | | | try: | | | pattern = re.compile(args.term, re.IGNORECASE) | | | except re.error as e: |
| | print(f"Invalid regex '{args.term}': {e}", file=sys.stderr) |
| | sys.exit(1) |
| | else: | | | term = args.term.lower() | | | | | | date_since, date_until = None, None | | | if args.date: | | | date_since, date_until = parse_date_filter(args.date) | | | | | | # Timeout: default 10s for fuzzy, 0 (unlimited) for exact/regex | | | timeout = args.timeout | | | if timeout is None: | | | timeout = 10 if use_fuzzy else 0 | | | timed_out = False | | | deadline = time.monotonic() + timeout if timeout > 0 else None | | | | | | results = [] | | | | | | project_dirs = _resolve_project_dirs(args) | | | if project_dirs is not None: | | | dirs_to_scan = [d for d in project_dirs if d.is_dir()] | | | else: | | | dirs_to_scan = sorted(PROJECTS_DIR.iterdir()) | | | | | | try: | | | for proj_dir in dirs_to_scan: | | | if not proj_dir.is_dir(): | | | continue |
| | label = project_label(proj_dir) |
| | if args.project and args.project.lower() not in label.lower(): |
| | continue | | | | | | for jsonl_file in proj_dir.glob("*.jsonl"): | | | if date_since is not None or date_until is not None: | | | file_ts = jsonl_file.stat().st_mtime | | | if date_since is not None and file_ts < date_since: | | | continue | | | if date_until is not None and file_ts > date_until: | | | continue | | | | | | session_id = jsonl_file.stem | | | title = None | | | messages = [] | | | |
| | for record in iter_jsonl(jsonl_file): |
| | rtype = record.get("type") |
| | if rtype == "ai-title" and record.get("aiTitle"): |
| | title = record["aiTitle"] |
| | if rtype in ("user", "assistant") and "message" in record: |
| | text = extract_text(record["message"].get("content", "")) |
| | text = strip_system_tags(text) |
| | # For fuzzy mode, skip very large blocks (tool output dumps) |
| | if use_fuzzy and len(text) > 5000: |
| | text = text[:5000] |
| | role = record["message"].get("role", rtype) |
| | messages.append((role, text)) |
| | |
| | for i, (role, text) in enumerate(messages): |
| | if deadline is not None and time.monotonic() > deadline: |
| | raise TimeoutError() |
| | if use_regex: | | | match_found = pattern.search(text) | | | elif use_fuzzy: | | | match_found = fuzzy_text_matches(args.term, text) | | | else: | | | match_found = term in text.lower() | | | if match_found: |
| | lines = text.split("\n") |
| | for li, line in enumerate(lines): |
| | if use_regex: | | | line_match = pattern.search(line) | | | elif use_fuzzy: | | | line_match = bool(fuzzy_line_matches(args.term, line)) | | | else: | | | line_match = term in line.lower() | | | if line_match: |
| | ctx_start = max(0, li - args.context) |
| | ctx_end = min(len(lines), li + args.context + 1) |
| | snippet = "\n".join(lines[ctx_start:ctx_end]) |
| | results.append({ |
| | "session_id": session_id, | | | "project": label, | | | "title": title or "(untitled)", | | | "role": role, | | | "snippet": snippet, | | | "line": li, | | | }) | | | except TimeoutError: | | | timed_out = True | | | | | | if args.json: | | | print(json.dumps(results, indent=2)) | | | return | | | | | | if not results: | | | print(f"No results for '{args.term}'.") | | | return | | | | | | seen_sessions = set() | | | for r in results: | | | sid = r["session_id"][:8] | | | header_needed = sid not in seen_sessions | | | seen_sessions.add(sid) | | | | | | if header_needed: |
| | print() |
| | print(f" {cyan(sid)} {dim('[' + r['project'] + ']')} {r['title']}") |
| | print(f" {'─' * 60}") |
| | |
| | role_color = green if r["role"] == "user" else yellow |
| | snippet = r["snippet"] |
| | if use_regex: | | | highlighted = pattern.sub(lambda m: bold(red(m.group(0))), snippet) | | | elif use_fuzzy: | | | highlighted = highlight_fuzzy(args.term, snippet) | | | else: |
| | highlighted = re.sub( |
| | re.escape(args.term), |
| | lambda m: bold(red(m.group(0))), |
| | snippet, | | | flags=re.IGNORECASE, | | | ) |
| | for line in highlighted.split("\n"): |
| | print(f" {role_color(r['role'] + ':')} {line}") |
| | | | | summary = f"{len(results)} match(es) across {len(seen_sessions)} session(s)" | | | if timed_out: |
| | summary += f" (timed out after {timeout}s — use --timeout N to increase)" |
| | print(f"\n {dim(summary)}") |
| | | | | | | | def cmd_read(args): | | | if not args.session_id: |
| | project_dirs = _resolve_project_dirs(args) |
| | sessions = list(discover_sessions(project_dirs=project_dirs)) |
| | sessions.sort(key=lambda s: s[4] or 0, reverse=True) |
| | use_fzf = getattr(args, "fzf", False) |
| | picked = interactive_pick_session(sessions, use_fzf=use_fzf) |
| | if not picked: | | | return | | | args.session_id = picked[0] | | | | | | path = find_session_file(args.session_id) | | | if not path: |
| | print(f"No session found matching '{args.session_id}'", file=sys.stderr) |
| | sys.exit(1) |
| | |
| | show_git = getattr(args, "git", False) |
| | show_ai = getattr(args, "ai", False) |
| | show_human = getattr(args, "human", False) |
| | show_full = getattr(args, "full", False) |
| | show_all_tools = getattr(args, "all_tools", False) |
| | | | | if show_all_tools and getattr(args, "no_tools", False): |
| | print("--all-tools and --no-tools are mutually exclusive", file=sys.stderr) |
| | sys.exit(1) |
| | | | | # Git mode: show commits and exit | | | if show_git: | | | commits = _extract_git_commits(path) | | | if not commits: | | | print(" No git commits found in this session.") | | | return |
| | print(f"\n {bold('Git commits')}") |
| | print(f" {'─' * 40}") |
| | for msg in commits: |
| | print(f" {msg}") |
| | print() |
| | return | | | | | | # Collect all messages for --ai / --human filtering | | | if show_ai or show_human: | | | records = [] | | | title = None |
| | for record in iter_jsonl(path): |
| | rtype = record.get("type") |
| | if rtype == "ai-title" and record.get("aiTitle") and title is None: |
| | title = record["aiTitle"] |
| | if rtype in ("user", "assistant"): |
| | records.append(record) |
| | | | | proj = project_label(path.parent) | | | if title: |
| | print(f"\n {bold(title)} {dim('[' + proj + ']')}") |
| | print(f" {dim(path.stem)}") |
| | print(f" {'━' * 60}\n") |
| | | | | target_role = "assistant" if show_ai else "user" | | | matching = [r for r in records if r.get("message", {}).get("role", r.get("type")) == target_role] | | | | | | if not matching: | | | print(f" No {target_role} messages found.") | | | return | | | | | | # Find the last message of that role with actual text content | | | record = None | | | text = "" |
| | for r in reversed(matching): |
| | msg = r.get("message", {}) |
| | content = msg.get("content", "") |
| | if show_all_tools: | | | candidate = _extract_all_tools_text(content) | | | elif show_full: | | | candidate = extract_text(content) | | | else: |
| | candidate = _extract_clean_text(content) |
| | candidate = strip_system_tags(candidate) |
| | if candidate.strip(): |
| | record = r | | | text = candidate | | | break | | | | | | if not record: | | | print(f" No {target_role} messages with content found.") | | | return | | | | | | role_color = green if target_role == "user" else yellow |
| | print(role_color(f" [{target_role}]")) |
| | for line in text.split("\n"): |
| | print(f" {line}") |
| | print() |
| | return | | | | | | # Default read mode | | | title = None |
| | for record in iter_jsonl(path): |
| | rtype = record.get("type") |
| | | | | if rtype == "ai-title" and record.get("aiTitle"): | | | if title is None: |
| | title = record["aiTitle"] |
| | proj = project_label(path.parent) |
| | print(f"\n {bold(title)} {dim('[' + proj + ']')}") |
| | print(f" {dim(path.stem)}") |
| | print(f" {'━' * 60}\n") |
| | | | | if rtype not in ("user", "assistant"): | | | continue | | | |
| | msg = record.get("message", {}) |
| | role = msg.get("role", rtype) |
| | content = msg.get("content", "") |
| | |
| | if args.no_tools and isinstance(content, list): |
| | content = [ |
| | item for item in content | | | if isinstance(item, dict) and item.get("type") not in ("tool_use", "tool_result") | | | ] | | | | | | if args.raw: | | | text = json.dumps(content, indent=2) if not isinstance(content, str) else content | | | elif show_all_tools: | | | text = _extract_all_tools_text(content) | | | elif show_full: |
| | text = extract_text(content) |
| | text = strip_system_tags(text) |
| | else: | | | text = _extract_clean_text(content) | | | | | | if not text.strip(): | | | continue | | | |
| | role_color = green if role == "user" else yellow |
| | prefix = role_color(f" [{role}]") |
| | print(prefix) |
| | for line in text.split("\n"): |
| | print(f" {line}") |
| | print() |
| | | | | | | | # ─── File extension categories ─────────────────────────────────────────────── | | | | | | EXT_CATEGORIES = { | | | "images": {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".svg", ".webp", ".ico", ".tiff"}, | | | "code": { | | | ".py", ".js", ".ts", ".tsx", ".jsx", ".c", ".cc", ".cpp", ".h", ".hpp", | | | ".rs", ".go", ".java", ".rb", ".sh", ".bash", ".zsh", ".lua", ".zig", | | | ".cs", ".swift", ".kt", ".scala", ".r", ".m", ".pl", ".php", ".ex", | | | ".html", ".css", ".scss", ".less", ".vue", ".svelte", | | | }, | | | "data": {".csv", ".tsv", ".json", ".jsonl", ".yaml", ".yml", ".xml", ".toml", ".ini", ".parquet", ".npy", ".npz"}, | | | "docs": {".md", ".txt", ".rst", ".tex", ".pdf", ".org", ".log"}, | | | "config": {".env", ".gitignore", ".dockerignore", ".editorconfig", ".prettierrc", ".eslintrc"}, | | | } | | | | | | # Tools that run shell commands (Claude Code on Windows can use PowerShell) | | | SHELL_TOOLS = ("Bash", "PowerShell") | | | | | | |
| | def categorize_file(filepath): |
| | ext = os.path.splitext(filepath)[1].lower() |
| | for cat, exts in EXT_CATEGORIES.items(): |
| | if ext in exts: | | | return cat | | | return "misc" | | | | | | | | | def _extract_tool_calls(path): | | | """Extract all tool calls from a session JSONL. Returns list of dicts.""" |
| | calls = [] |
| | for record in iter_jsonl(path): |
| | if record.get("type") != "assistant": |
| | continue |
| | content = record.get("message", {}).get("content", []) |
| | if not isinstance(content, list): |
| | continue | | | for item in content: | | | if not isinstance(item, dict) or item.get("type") != "tool_use": | | | continue |
| | name = item.get("name", "?") |
| | inp = item.get("input", {}) |
| | call = {"tool": name, "input": inp} |
| | |
| | if name in ("Read", "Write", "Edit"): |
| | call["file"] = inp.get("file_path", "") |
| | elif name in SHELL_TOOLS: | | | call["command"] = inp.get("command", "") | | | | | | calls.append(call) | | | return calls | | | | | | | | | def cmd_tools(args): | | | """List tool/MCP calls made in a session.""" | | | path = find_session_file(args.session_id) | | | if not path: |
| | print(f"No session found matching '{args.session_id}'", file=sys.stderr) |
| | sys.exit(1) |
| | | | | calls = extract_tool_calls(path) | | | | | | if args.mcp_only: | | | calls = [c for c in calls if c["tool"].startswith("mcp_")] | | | if args.no_bash: | | | calls = [c for c in calls if c["tool"] not in SHELL_TOOLS] | | | | | | if args.json: | | | print(json.dumps(calls, indent=2)) | | | return | | | | | | if not calls: | | | print(" No tool calls found.") | | | return | | | | | | # Group and display | | | tool_counts = defaultdict(int) | | | for c in calls: | | | tool_counts[c["tool"]] += 1 | | | | | | if args.summary: |
| | print(f"\n {bold('Tool call summary')}") |
| | print(f" {'─' * 40}") |
| | for tool, count in sorted(tool_counts.items(), key=lambda x: -x[1]): |
| | is_mcp = tool.startswith("mcp__") |
| | label = magenta(tool) if is_mcp else cyan(tool) |
| | print(f" {count:4d}x {label}") |
| | print(f"\n {dim(f'{len(calls)} total calls')}") |
| | return | | | | | | for c in calls: |
| | tool = c["tool"] |
| | is_mcp = tool.startswith("mcp__") |
| | label = magenta(tool) if is_mcp else cyan(tool) |
| | | | | detail = "" | | | if "file" in c: | | | detail = dim(c["file"]) | | | elif "command" in c: |
| | cmd = c["command"][:100].split("\n")[0] |
| | detail = dim(cmd) |
| | elif is_mcp: |
| | inp_str = json.dumps(c["input"]) |
| | if len(inp_str) > 100: |
| | inp_str = inp_str[:100] + "..." |
| | detail = dim(inp_str) |
| | | | | print(f" {label} {detail}") | | | | | | print(f"\n {dim(f'{len(calls)} total calls')}") | | | | | | | | | def cmd_files(args): | | | """List files accessed in a session, categorized by type.""" | | | path = find_session_file(args.session_id) | | | if not path: |
| | print(f"No session found matching '{args.session_id}'", file=sys.stderr) |
| | sys.exit(1) |
| | | | | calls = _extract_tool_calls(path) | | | | | | files_by_cat = defaultdict(lambda: defaultdict(set)) # cat -> {filepath -> set(operations)} | | | | | | for c in calls: | | | tool = c["tool"] | | | # Only Read/Write/Edit; file paths inside shell commands can't be extracted reliably |
| | if tool in ("Read", "Write", "Edit"): |
| | fp = c.get("file", "") |
| | if not fp: | | | continue |
| | cat = categorize_file(fp) |
| | op = tool.lower() |
| | files_by_cat[cat][fp].add(op) |
| | | | | # Apply category filters |
| | selected_cats = set() |
| | if args.images: selected_cats.add("images") |
| | if args.code: selected_cats.add("code") |
| | if args.data: selected_cats.add("data") |
| | if args.docs: selected_cats.add("docs") |
| | if args.config: selected_cats.add("config") |
| | if args.misc: selected_cats.add("misc") |
| | | | | if not selected_cats: | | | selected_cats = set(EXT_CATEGORIES.keys()) | {"misc"} | | | | | | if args.json: |
| | out = {} |
| | for cat in sorted(files_by_cat): |
| | if cat not in selected_cats: | | | continue |
| | out[cat] = {fp: sorted(ops) for fp, ops in files_by_cat[cat].items()} |
| | print(json.dumps(out, indent=2)) |
| | return | | | | | | total = 0 | | | for cat in ["images", "code", "data", "docs", "config", "misc"]: | | | if cat not in selected_cats or cat not in files_by_cat: | | | continue |
| | entries = files_by_cat[cat] |
| | cat_color = {"images": magenta, "code": cyan, "data": yellow, "docs": green, "config": dim, "misc": dim} |
| | color_fn = cat_color.get(cat, dim) |
| | print(f"\n {bold(color_fn(cat.upper()))} ({len(entries)} files)") |
| | for fp, ops in sorted(entries.items()): |
| | ops_str = ",".join(sorted(ops)) |
| | print(f" {dim(f'[{ops_str}]'):20s} {fp}") |
| | total += 1 | | | | | | print(f"\n {dim(f'{total} files across {len([c for c in files_by_cat if c in selected_cats])} categories')}") | | | | | | | | | def _extract_messages(path): | | | """Extract all user/assistant messages from a session. Returns list of (role, text) tuples.""" |
| | messages = [] |
| | for record in iter_jsonl(path): |
| | if record.get("type") not in ("user", "assistant"): |
| | continue |
| | msg = record.get("message", {}) |
| | role = msg.get("role", record["type"]) |
| | text = extract_text(msg.get("content", "")) |
| | text = strip_system_tags(text) |
| | if text.strip(): |
| | messages.append((role, text)) |
| | return messages | | | | | | | | | def _extract_git_commits(path): | | | """Extract git commit messages from Bash tool calls in a session.""" |
| | commits = [] |
| | calls = _extract_tool_calls(path) |
| | for c in calls: | | | if c["tool"] not in SHELL_TOOLS: | | | continue | | | cmd = c.get("command", "") | | | if "git commit" not in cmd: | | | continue | | | # Extract the commit message from a bash HEREDOC, a PowerShell here-string, or -m "..." | | | m = re.search(r'git commit.?-m\s+"?$(cat <<'?EOF'?\n(.?)\nEOF', cmd, re.DOTALL) | | | if m: | | | commits.append(m.group(1).strip().split("\n")[0]) | | | continue | | | m = re.search(r'git commit.?-m\s+@['"]\r?\n(.?)\r?\n['"]@', cmd, re.DOTALL) | | | if m: | | | commits.append(m.group(1).strip().split("\n")[0]) | | | continue | | | m = re.search(r'git commit.?-m\s+"([^"]+)"', cmd) | | | if m: | | | commits.append(m.group(1).strip().split("\n")[0]) | | | continue | | | m = re.search(r"git commit.?-m\s+'([^']+)'", cmd) | | | if m: | | | commits.append(m.group(1).strip().split("\n")[0]) | | | return commits | | | | | | | | | def _truncate(text, max_len, suffix="..."): | | | """Truncate text to max_len, appending suffix and char count if truncated.""" | | | if len(text) <= max_len: | | | return text |
| | remaining = len(text) - max_len |
| | return text[:max_len] + f"{suffix} (+{remaining} chars)" |
| | | | | | | | def _extract_clean_text(content): | | | """Extract text from message content, replacing file diffs with placeholders.""" | | | if isinstance(content, str): | | | return strip_system_tags(content) | | | if not isinstance(content, list): | | | return "" | | | parts = [] | | | for item in content: | | | if not isinstance(item, dict): | | | continue |
| | itype = item.get("type", "") |
| | if itype == "text": |
| | parts.append(item.get("text", "")) |
| | elif itype == "tool_use": |
| | name = item.get("name", "?") |
| | inp = item.get("input", {}) |
| | if name in ("Read", "Write", "Edit"): |
| | fp = inp.get("file_path", "") |
| | parts.append(f"[{name.lower()}: {fp}]") |
| | elif name in SHELL_TOOLS: |
| | cmd = inp.get("command", "").split("\n")[0][:80] |
| | parts.append(f"[{name.lower()}: {cmd}]") |
| | elif name.startswith("mcp__"): |
| | parts.append(f"[mcp: {name}]") |
| | else: |
| | parts.append(f"[{name}]") |
| | elif itype == "tool_result": |
| | rc = item.get("content", "") |
| | rc_text = "" | | | if isinstance(rc, str): | | | rc_text = rc |
| | elif isinstance(rc, list): |
| | rc_text = " ".join( |
| | r.get("text", "") for r in rc |
| | if isinstance(r, dict) and r.get("type") == "text" |
| | ) | | | # Detect file diffs/contents and replace with placeholder |
| | lines = rc_text.split("\n") |
| | if len(lines) > 10 and any(l.startswith(("---", "+++", "@@", "diff ")) for l in lines[:5]): |
| | parts.append(f"[diff output, {len(lines)} lines]") |
| | elif len(lines) > 15: |
| | parts.append(f"[output, {len(lines)} lines]") |
| | elif rc_text.strip(): |
| | parts.append(rc_text) |
| | text = "\n".join(parts) |
| | return strip_system_tags(text) |
| | | | | | | | def _extract_all_tools_text(content): | | | """Extract text showing every tool_use with full input and every tool_result in full.""" | | | if isinstance(content, str): | | | return strip_system_tags(content) | | | if not isinstance(content, list): | | | return "" | | | parts = [] | | | for item in content: | | | if not isinstance(item, dict): | | | continue |
| | itype = item.get("type", "") |
| | if itype == "text": |
| | parts.append(item.get("text", "")) |
| | elif itype == "tool_use": |
| | name = item.get("name", "?") |
| | inp = item.get("input", {}) |
| | try: |
| | inp_str = json.dumps(inp, indent=2, ensure_ascii=False) |
| | except (TypeError, ValueError): |
| | inp_str = repr(inp) |
| | parts.append(f"[tool_use: {name}]\n{inp_str}") |
| | elif itype == "tool_result": |
| | rc = item.get("content", "") |
| | if isinstance(rc, str): |
| | rc_text = rc |
| | elif isinstance(rc, list): |
| | rc_text = "\n".join( |
| | r.get("text", "") for r in rc |
| | if isinstance(r, dict) and r.get("type") == "text" |
| | ) | | | else: | | | rc_text = "" |
| | parts.append(f"[tool_result]\n{rc_text}") |
| | text = "\n".join(parts) |
| | return strip_system_tags(text) |
| | | | | | | | def cmd_summary(args): | | | """Show a summary of recent sessions: conversations, files, and commits.""" |
| | project_dirs = _resolve_project_dirs(args) |
| | sessions = list(discover_sessions(project_dirs=project_dirs)) |
| | sessions.sort(key=lambda s: s[4] or 0, reverse=True) |
| | sessions = sessions[:args.limit] |
| | | | | if not sessions: | | | print(" No sessions found.") | | | return | | | | | | # ── Git commits across recent sessions ── | | | all_commits = [] | | | for sid, proj, path, title, ts in sessions: | | | commits = _extract_git_commits(Path(path)) | | | for msg in commits: |
| | date_str = datetime.fromtimestamp(ts).strftime("%Y-%m-%d") if ts else "?" |
| | all_commits.append((date_str, proj, msg)) |
| | | | | if all_commits: |
| | print(f"\n {bold('Git commits')}") |
| | print(f" {'─' * 60}") |
| | for date_str, proj, msg in all_commits[:8]: |
| | print(f" {dim(date_str)} {dim('[' + proj + ']')} {msg[:80]}") |
| | if len(all_commits) > 8: |
| | print(f" {dim(f'... +{len(all_commits) - 8} more')}") |
| | print() |
| | | | | # ── Recent conversations ── |
| | print(f" {bold('Recent conversations')}") |
| | print(f" {'─' * 60}") |
| | for sid, proj, path, title, ts in sessions: |
| | date_str = datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M") if ts else "?" |
| | short_id = sid[:8] |
| | print(f"\n {cyan(short_id)} {dim(date_str)} {dim('[' + proj + ']')} {bold(title)}") |
| | | | | messages = _extract_messages(Path(path)) | | | # Show first user message (3 lines max) | | | for role, text in messages: |
| | if role == "user": |
| | lines = [l for l in text.split("\n") if l.strip()][:3] |
| | for line in lines: |
| | print(f" {green('>')} {_truncate(line, 90)}") |
| | if len([l for l in text.split("\n") if l.strip()]) > 3: |
| | print(f" {dim('...')}") |
| | break | | | | | | # Show last assistant message (2 lines max, truncated) |
| | for role, text in reversed(messages): |
| | if role == "assistant": |
| | lines = [l for l in text.split("\n") if l.strip()][:2] |
| | for line in lines: |
| | print(f" {yellow('<')} {_truncate(line, 80)}") |
| | remaining_lines = len([l for l in text.split("\n") if l.strip()]) - 2 |
| | if remaining_lines > 0: |
| | print(f" {dim(f' ... +{remaining_lines} lines')}") |
| | break | | | | | | # ── Files across recent sessions ── | | | all_files = defaultdict(lambda: {"ops": set(), "session": None, "ts": 0}) | | | for sid, proj, path, title, ts in sessions: | | | calls = _extract_tool_calls(Path(path)) | | | for c in calls: |
| | if c["tool"] in ("Read", "Write", "Edit"): |
| | fp = c.get("file", "") |
| | if not fp: | | | continue |
| | entry = all_files[fp] |
| | entry["ops"].add(c["tool"].lower()) |
| | if ts and ts > entry["ts"]: |
| | entry["ts"] = ts |
| | entry["session"] = sid[:8] |
| | | | | if all_files: |
| | by_cat = defaultdict(list) |
| | for fp, info in all_files.items(): |
| | cat = categorize_file(fp) |
| | by_cat[cat].append((fp, info)) |
| | | | | # Sort each category by timestamp descending | | | for cat in by_cat: | | | by_cat[cat].sort(key=lambda x: -x[1]["ts"]) | | | |
| | print(f"\n\n {bold('Files touched')}") |
| | print(f" {'─' * 60}") |
| | | | | cat_order = ["images", "code", "data", "docs", "config", "misc"] | | | for cat in cat_order: | | | if cat not in by_cat: | | | continue |
| | entries = by_cat[cat] |
| | cat_color = {"images": magenta, "code": cyan, "data": yellow, "docs": green, "config": dim, "misc": dim} |
| | color_fn = cat_color.get(cat, dim) |
| | |
| | shown = entries[:3] |
| | extra = len(entries) - 3 |
| | print(f"\n {color_fn(cat.upper())} ({len(entries)} files)") |
| | |
| | for i, (fp, info) in enumerate(shown): |
| | age = f"T-{i}" if i > 0 else "T " |
| | ops = ",".join(sorted(info["ops"])) |
| | basename = os.path.basename(fp) |
| | dirname = os.path.dirname(fp) |
| | # Shorten home prefix |
| | dirname = dirname.replace(str(Path.home()), "~") |
| | print(f" {dim(age)} {dim(f'[{ops}]'):18s} {basename} {dim(dirname)}") |
| | |
| | if extra > 0: |
| | print(f" {dim(f' +{extra} more')}") |
| | | | | print() | | | | | | | | | def cmd_index(args): | | | """Build a term-frequency index across all sessions for fast search.""" |
| | print("Building index...") |
| | index = {} |
| | count = 0 | | | | | | for sid, proj, path, title, ts in discover_sessions(): | | | count += 1 | | | terms = defaultdict(int) | | | |
| | for record in iter_jsonl(path): |
| | if record.get("type") not in ("user", "assistant"): |
| | continue |
| | text = extract_text(record.get("message", {}).get("content", "")) |
| | text = strip_system_tags(text).lower() |
| | # Tokenize: split on non-alphanumeric, keep tokens >= 3 chars |
| | for word in re.findall(r"[a-z0-9_]{3,}", text): |
| | terms[word] += 1 |
| | | | | # Keep top 100 terms per session (skip ultra-common ones) | | | STOPWORDS = { | | | "the", "and", "for", "that", "this", "with", "you", "are", "from", | | | "have", "has", "was", "were", "will", "can", "not", "but", "they", | | | "been", "would", "could", "should", "which", "their", "there", | | | "about", "into", "than", "then", "them", "these", "those", | | | "some", "other", "its", "your", "our", "what", "when", "how", | | | "all", "each", "more", "also", "use", "used", "using", | | | "text", "type", "tool", "name", "content", "message", | | | } |
| | filtered = {k: v for k, v in terms.items() if k not in STOPWORDS} |
| | top = sorted(filtered.items(), key=lambda x: -x[1])[:100] |
| | | | | index[sid] = { | | | "project": proj, | | | "title": title, | | | "timestamp": ts, |
| | "date": datetime.fromtimestamp(ts).isoformat() if ts else None, |
| | "terms": {k: v for k, v in top}, |
| | } | | | |
| | INDEX_PATH.parent.mkdir(parents=True, exist_ok=True) |
| | with open(INDEX_PATH, "w", encoding="utf-8") as f: |
| | json.dump(index, f, indent=1) |
| | |
| | total_terms = sum(len(v["terms"]) for v in index.values()) |
| | print(f"Indexed {count} sessions, {total_terms} unique terms.") |
| | print(f"Index saved to {INDEX_PATH}") |
| | | | | |
| | def cmd_projects(args): |
| | projects = defaultdict(int) |
| | for proj_dir in sorted(PROJECTS_DIR.iterdir()): |
| | if not proj_dir.is_dir(): |
| | continue |
| | label = project_label(proj_dir) |
| | count = sum(1 for _ in proj_dir.glob("*.jsonl")) |
| | projects[label] = count |
| | |
| | for proj, count in sorted(projects.items(), key=lambda x: -x[1]): |
| | print(f" {cyan(f'{count:3d}')} sessions {proj}") |
| | | | | | | | def cmd_stats(args): | | | total_sessions = 0 | | | total_messages = 0 | | | total_bytes = 0 | | | by_project = defaultdict(lambda: {"sessions": 0, "messages": 0, "bytes": 0}) | | | |
| | for proj_dir in sorted(PROJECTS_DIR.iterdir()): |
| | if not proj_dir.is_dir(): |
| | continue | | | label = project_label(proj_dir) | | | | | | for jsonl_file in proj_dir.glob("*.jsonl"): | | | total_sessions += 1 |
| | by_project[label]["sessions"] += 1 |
| | fsize = jsonl_file.stat().st_size |
| | total_bytes += fsize | | | by_project[label]["bytes"] += fsize | | | |
| | for record in iter_jsonl(jsonl_file): |
| | if record.get("type") in ("user", "assistant"): |
| | total_messages += 1 | | | by_project[label]["messages"] += 1 | | | |
| | print(f"\n {bold('Claude Code History Stats')}") |
| | print(f" {'━' * 40}") |
| | print(f" Sessions: {total_sessions}") |
| | print(f" Messages: {total_messages}") |
| | print(f" Size: {total_bytes / 1024 / 1024:.1f} MB") |
| | print() |
| | |
| | for proj, s in sorted(by_project.items(), key=lambda x: -x[1]["sessions"]): |
| | print(f" {cyan(proj):40s} {s['sessions']:3d} sessions {s['messages']:5d} msgs {s['bytes']/1024:.0f} KB") |
| | print() |
| | | | | | | | # ─── Completions ───────────────────────────────────────────────────────────── | | | | | | ZSH_COMPLETION = r''' | | | #compdef cc-history | | | | | | _cc-history() { | | | local -a commands | | | commands=( | | | 'list:List sessions' | | | 'ls:List sessions' | | | 'search:Search conversations' | | | 's:Search conversations' | | | 'grep:Search conversations' | | | 'read:Read a session' | | | 'r:Read a session' | | | 'show:Read a session' | | | 'summary:Summary of recent sessions' | | | 'tools:List tool/MCP calls' | | | 't:List tool/MCP calls' | | | 'calls:List tool/MCP calls' | | | 'files:List files accessed' | | | 'f:List files accessed' | | | 'index:Build search term index' | | | 'projects:List projects' | | | 'p:List projects' | | | 'stats:Show stats' | | | 'completions:Generate shell completions' | | | ) | | | | | | _arguments -C \ |
| | '1:command:->command' \ |
| | '*::arg:->args' |
| | | | | case "$state" in | | | command) | | | _describe -t commands 'cc-history command' commands | | | ;; | | | args) | | | case "$words[1]" in | | | list|ls) | | | _arguments \ |
| | '(-g --global)'{-g,--global}'[Search all projects]' \ |
| | '(-p --project)'{-p,--project}'[Filter by project]:project:_cc_history_projects' \ |
| | '(-n --limit)'{-n,--limit}'[Max sessions to show]:limit:' \ |
| | '(-d --date)'{-d,--date}'[Filter by date]:date expression:' \ |
| | '--json[JSON output]' \ |
| | '--pick[Interactive picker]' \ |
| | '--fzf[Use fzf for picker]' |
| | ;; |
| | search|s|grep) | | | _arguments \ |
| | '1:search term:' \ |
| | '(-g --global)'{-g,--global}'[Search all projects]' \ |
| | '(-E --regex)'{-E,--regex}'[Treat term as regex]' \ |
| | '(-F --fuzzy)'{-F,--fuzzy}'[Fuzzy match]' \ |
| | '(-p --project)'{-p,--project}'[Filter by project]:project:_cc_history_projects' \ |
| | '(-d --date)'{-d,--date}'[Filter by date]:date expression:' \ |
| | '(-C --context)'{-C,--context}'[Lines of context]:lines:' \ |
| | '--json[JSON output]' |
| | ;; |
| | read|r|show) | | | _arguments \ | | | '1:session ID:_cc_history_sessions' \ |
| | '(-g --global)'{-g,--global}'[Pick from all projects]' \ |
| | '--ai[Show last AI message]' \ |
| | '--human[Show last human message]' \ |
| | '--git[Show git commits]' \ |
| | '--full[Show full unabridged content]' \ |
| | '--raw[Show raw JSON content]' \ |
| | '--no-tools[Hide tool blocks]' \ |
| | '--all-tools[Show every tool call in full]' \ |
| | '--fzf[Use fzf for picker]' |
| | ;; |
| | summary) | | | _arguments \ |
| | '(-g --global)'{-g,--global}'[Include all projects]' \ |
| | '(-n --limit)'{-n,--limit}'[Number of sessions]:count:' |
| | ;; |
| | tools|t|calls) | | | _arguments \ | | | '1:session ID:_cc_history_sessions' \ |
| | '--mcp-only[Only MCP calls]' \ |
| | '--no-bash[Hide Bash calls]' \ |
| | '--summary[Count summary only]' \ |
| | '--json[JSON output]' |
| | ;; |
| | files|f) | | | _arguments \ | | | '1:session ID:_cc_history_sessions' \ |
| | '--images[Only image files]' \ |
| | '--code[Only code files]' \ |
| | '--data[Only data files]' \ |
| | '--docs[Only document files]' \ |
| | '--config[Only config files]' \ |
| | '--misc[Only uncategorized files]' \ |
| | '--json[JSON output]' |
| | ;; |
| | completions) |
| | _arguments '1:shell:(zsh bash fish powershell)' |
| | ;; |
| | esac | | | ;; | | | esac | | | } | | | | | | _cc_history_projects() { | | | local -a projects | | | projects=(${(f)"$(cc-history projects 2>/dev/null | sed 's/[1][0-9] sessions[[:space:]]*//')"}) | | | _describe -t projects 'project' projects | | | } | | | | | | _cc_history_sessions() { | | | local -a sessions |
| | local idx="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/cache/cc-history-index.json" |
| | if [[ -f $idx ]]; then |
| | sessions=(${(f)"$(python3 -c " |
| | import json, sys |
| | with open(sys.argv[1], encoding='utf-8') as f: |
| | idx = json.load(f) |
| | for sid, info in sorted(idx.items(), key=lambda x: x[1].get('timestamp') or 0, reverse=True)[:30]: |
| | title = info.get('title', '').replace(':', ' ').replace(\"'\", '')[:60] |
| | print(f'{sid[:8]}:{title}') |
| | " "$idx" 2>/dev/null)"}) |
| | else | | | sessions=(${(f)"$(cc-history list --limit 30 2>/dev/null | sed -n 's/[2]$[a-f0-9]{8}$./\1/p')"}) | | | fi | | | _describe -t sessions 'session' sessions | | | } | | | | | | compdef _cc-history cc-history | | | ''' | | | | | | BASH_COMPLETION = r''' | | | _cc_history() { | | | local cur prev commands |
| | COMPREPLY=() |
| | cur="${COMP_WORDS[COMP_CWORD]}" |
| | prev="${COMP_WORDS[COMP_CWORD-1]}" |
| | | | | commands="list ls search s grep read r show summary tools t calls files f index projects p stats completions" | | | |
| | if [[ ${COMP_CWORD} -eq 1 ]]; then |
| | COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") ) |
| | return 0 | | | fi | | | | | | local subcmd="${COMP_WORDS[1]}" | | | | | | case "${subcmd}" in | | | list|ls) |
| | COMPREPLY=( $(compgen -W "-g --global --project -p --limit -n --date -d --json --pick --fzf" -- "${cur}") ) |
| | if [[ "${prev}" == "-p" \|\| "${prev}" == "--project" ]]; then |
| | local projects |
| | projects=$(cc-history projects 2>/dev/null \| sed 's/^[[:space:]]*[0-9]* sessions[[:space:]]*//') |
| | COMPREPLY=( $(compgen -W "${projects}" -- "${cur}") ) |
| | fi | | | ;; | | | search|s|grep) |
| | COMPREPLY=( $(compgen -W "-g --global --regex -E --fuzzy -F --project -p --date -d --context -C --json" -- "${cur}") ) |
| | if [[ "${prev}" == "-p" \|\| "${prev}" == "--project" ]]; then |
| | local projects |
| | projects=$(cc-history projects 2>/dev/null \| sed 's/^[[:space:]]*[0-9]* sessions[[:space:]]*//') |
| | COMPREPLY=( $(compgen -W "${projects}" -- "${cur}") ) |
| | fi | | | ;; | | | read|r|show) | | | if [[ ${COMP_CWORD} -eq 2 ]]; then | | | local sessions |
| | sessions=$(cc-history list --limit 30 2>/dev/null \| sed -n 's/^[[:space:]]*$[a-f0-9]\{8\}$.*/\1/p') |
| | COMPREPLY=( $(compgen -W "${sessions} -g --global --fzf" -- "${cur}") ) |
| | else | | | COMPREPLY=( $(compgen -W "--ai --human --git --full --raw --no-tools --all-tools" -- "${cur}") ) | | | fi | | | ;; | | | summary) |
| | COMPREPLY=( $(compgen -W "-g --global --limit -n" -- "${cur}") ) |
| | ;; |
| | tools|t|calls) | | | if [[ ${COMP_CWORD} -eq 2 ]]; then | | | local sessions |
| | sessions=$(cc-history list --limit 30 2>/dev/null \| sed -n 's/^[[:space:]]*$[a-f0-9]\{8\}$.*/\1/p') |
| | COMPREPLY=( $(compgen -W "${sessions}" -- "${cur}") ) |
| | else | | | COMPREPLY=( $(compgen -W "--mcp-only --no-bash --summary --json" -- "${cur}") ) | | | fi | | | ;; | | | files|f) | | | if [[ ${COMP_CWORD} -eq 2 ]]; then | | | local sessions |
| | sessions=$(cc-history list --limit 30 2>/dev/null \| sed -n 's/^[[:space:]]*$[a-f0-9]\{8\}$.*/\1/p') |
| | COMPREPLY=( $(compgen -W "${sessions}" -- "${cur}") ) |
| | else | | | COMPREPLY=( $(compgen -W "--images --code --data --docs --config --misc --json" -- "${cur}") ) | | | fi | | | ;; | | | completions) |
| | COMPREPLY=( $(compgen -W "zsh bash fish powershell" -- "${cur}") ) |
| | ;; |
| | esac | | | return 0 | | | } | | | complete -F _cc_history cc-history | | | ''' | | | | | | FISH_COMPLETION = r''' | | | # Disable file completions for cc-history | | | complete -c cc-history -f | | | | | | # Subcommands | | | complete -c cc-history -n "__fish_use_subcommand" -a "list ls" -d "List sessions" | | | complete -c cc-history -n "__fish_use_subcommand" -a "search s grep" -d "Search conversations" | | | complete -c cc-history -n "__fish_use_subcommand" -a "read r show" -d "Read a session" | | | complete -c cc-history -n "__fish_use_subcommand" -a "summary" -d "Summary of recent sessions" | | | complete -c cc-history -n "__fish_use_subcommand" -a "tools t calls" -d "List tool/MCP calls" | | | complete -c cc-history -n "__fish_use_subcommand" -a "files f" -d "List files accessed" | | | complete -c cc-history -n "__fish_use_subcommand" -a "index" -d "Build search term index" |
| | complete -c cc-history -n "__fish_use_subcommand" -a "projects p" -d "List projects" |
| | complete -c cc-history -n "__fish_use_subcommand" -a "stats" -d "Show stats" |
| | complete -c cc-history -n "__fish_use_subcommand" -a "completions" -d "Generate shell completions" | | | | | | # list flags |
| | complete -c cc-history -n "__fish_seen_subcommand_from list ls" -s p -l project -d "Filter by project" -x -a "(cc-history projects 2>/dev/null \| string replace -r '^\s*\d+ sessions\s+' '')" |
| | complete -c cc-history -n "__fish_seen_subcommand_from list ls" -s n -l limit -d "Max sessions" |
| | complete -c cc-history -n "__fish_seen_subcommand_from list ls" -l json -d "JSON output" | | | complete -c cc-history -n "__fish_seen_subcommand_from list ls" -l pick -d "Interactive picker" | | | complete -c cc-history -n "__fish_seen_subcommand_from list ls" -l fzf -d "Use fzf for picker" | | | complete -c cc-history -n "__fish_seen_subcommand_from list ls" -s d -l date -d "Filter by date" | | | | | | # search flags |
| | complete -c cc-history -n "__fish_seen_subcommand_from search s grep" -s E -l regex -d "Regex mode" |
| | complete -c cc-history -n "__fish_seen_subcommand_from search s grep" -s F -l fuzzy -d "Fuzzy match" |
| | complete -c cc-history -n "__fish_seen_subcommand_from search s grep" -s p -l project -d "Filter by project" -x -a "(cc-history projects 2>/dev/null | string replace -r '^\s*\d+ sessions\s+' '')" |
| | complete -c cc-history -n "__fish_seen_subcommand_from search s grep" -s d -l date -d "Filter by date" |
| | complete -c cc-history -n "__fish_seen_subcommand_from search s grep" -s C -l context -d "Context lines" |
| | complete -c cc-history -n "__fish_seen_subcommand_from search s grep" -l json -d "JSON output" | | | | | | # read flags | | | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -l raw -d "Raw JSON content" | | | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -l no-tools -d "Hide tool blocks" | | | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -l all-tools -d "Show every tool call in full" | | | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -l ai -d "Last AI message" | | | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -l human -d "Last human message" | | | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -l git -d "Show git commits" | | | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -l full -d "Full unabridged content" | | | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -l fzf -d "Use fzf for picker" | | | | | | # summary flags |
| | complete -c cc-history -n "__fish_seen_subcommand_from summary" -s g -l global -d "Include all projects" |
| | complete -c cc-history -n "__fish_seen_subcommand_from summary" -s n -l limit -d "Number of sessions" |
| | complete -c cc-history -n "__fish_seen_subcommand_from read r show" -x -a "(cc-history list --limit 30 2>/dev/null \| string replace -r '^\s*([a-f0-9]{8}).*' '\$1')" |
| | | | | # tools flags |
| | complete -c cc-history -n "__fish_seen_subcommand_from tools t calls" -l mcp-only -d "Only MCP calls" |
| | complete -c cc-history -n "__fish_seen_subcommand_from tools t calls" -l no-bash -d "Hide Bash calls" |
| | complete -c cc-history -n "__fish_seen_subcommand_from tools t calls" -l summary -d "Count summary" | | | complete -c cc-history -n "__fish_seen_subcommand_from tools t calls" -l json -d "JSON output" | | | | | | # files flags | | | complete -c cc-history -n "__fish_seen_subcommand_from files f" -l images -d "Only images" | | | complete -c cc-history -n "__fish_seen_subcommand_from files f" -l code -d "Only code" | | | complete -c cc-history -n "__fish_seen_subcommand_from files f" -l data -d "Only data files" | | | complete -c cc-history -n "__fish_seen_subcommand_from files f" -l docs -d "Only documents" | | | complete -c cc-history -n "__fish_seen_subcommand_from files f" -l config -d "Only config" | | | complete -c cc-history -n "__fish_seen_subcommand_from files f" -l misc -d "Only uncategorized" | | | complete -c cc-history -n "__fish_seen_subcommand_from files f" -l json -d "JSON output" | | | | | | # completions flags | | | complete -c cc-history -n "__fish_seen_subcommand_from completions" -x -a "zsh bash fish powershell" | | | ''' | | | | | | POWERSHELL_COMPLETION = r''' | | | Register-ArgumentCompleter -Native -CommandName cc-history, cc-history.exe -ScriptBlock { | | | param($wordToComplete, $commandAst, $cursorPosition) | | | |
| | $commands = [ordered]@{ |
| | 'list' = 'List sessions'; 'search' = 'Search conversations'; 'read' = 'Read a session' |
| | 'summary' = 'Summary of recent sessions'; 'tools' = 'List tool/MCP calls' | | | 'files' = 'List files accessed'; 'index' = 'Build search term index' | | | 'projects' = 'List projects'; 'stats' = 'Show stats'; 'completions' = 'Generate shell completions' | | | } |
| | $aliases = @{ 'ls' = 'list'; 's' = 'search'; 'grep' = 'search'; 'r' = 'read'; 'show' = 'read' |
| | 't' = 'tools'; 'calls' = 'tools'; 'f' = 'files'; 'p' = 'projects' } |
| | $flags = @{ |
| | 'list' = @('-g', '--global', '-p', '--project', '-n', '--limit', '-d', '--date', '--json', '--pick', '--fzf') |
| | 'search' = @('-g', '--global', '-E', '--regex', '-F', '--fuzzy', '-p', '--project', '-d', '--date', '-C', '--context', '-T', '--timeout', '--json') |
| | 'read' = @('-g', '--global', '--ai', '--human', '--git', '--full', '--raw', '--no-tools', '--all-tools', '--fzf') |
| | 'summary' = @('-g', '--global', '-n', '--limit') |
| | 'tools' = @('--mcp-only', '--no-bash', '--summary', '--json') |
| | 'files' = @('--images', '--code', '--data', '--docs', '--config', '--misc', '--json') |
| | 'completions' = @('zsh', 'bash', 'fish', 'powershell') | | | } | | | |
| | $words = @($commandAst.CommandElements \| ForEach-Object { $_.ToString() }) |
| | if ($words.Count -lt 2 -or ($words.Count -eq 2 -and $wordToComplete)) { |
| | foreach ($cmd in $commands.Keys) { |
| | if ($cmd -like "$wordToComplete*") { |
| | [System.Management.Automation.CompletionResult]::new($cmd, $cmd, 'ParameterValue', $commands[$cmd]) |
| | } | | | } | | | return | | | } | | | |
| | $sub = $words[1] |
| | if ($aliases.ContainsKey($sub)) { $sub = $aliases[$sub] } |
| | $candidates = @() |
| | if ($sub -in 'read', 'tools', 'files' -and -not $wordToComplete.StartsWith('-')) { |
| | $candidates += @(cc-history list --limit 30 --json 2>$null \| ConvertFrom-Json) \| |
| | ForEach-Object { $_.session_id.Substring(0, 8) } |
| | } |
| | if ($flags.ContainsKey($sub)) { $candidates += $flags[$sub] } |
| | foreach ($c in $candidates) { |
| | if ($c -like "$wordToComplete*") { |
| | [System.Management.Automation.CompletionResult]::new($c, $c, 'ParameterValue', $c) |
| | } | | | } | | | } | | | ''' | | | | | | | | | def cmd_completions(args): | | | shell = args.shell | | | if shell is None: | | | shell_env = os.environ.get("SHELL", "") | | | if "zsh" in shell_env: | | | shell = "zsh" | | | elif "fish" in shell_env: | | | shell = "fish" | | | elif IS_WINDOWS and not shell_env: | | | shell = "powershell" | | | else: | | | shell = "bash" | | | |
| | if shell == "zsh": |
| | print(ZSH_COMPLETION.strip()) |
| | elif shell == "bash": |
| | print(BASH_COMPLETION.strip()) |
| | elif shell == "fish": |
| | print(FISH_COMPLETION.strip()) |
| | elif shell == "powershell": |
| | print(POWERSHELL_COMPLETION.strip()) |
| | | | | | | | # ─── Main ──────────────────────────────────────────────────────────────────── | | | | | | def main(): | | | parser = argparse.ArgumentParser( | | | prog="cc-history", | | | description="Browse and search Claude Code conversation history.", | | | ) | | | sub = parser.add_subparsers(dest="command") | | | | | | # list |
| | p_list = sub.add_parser("list", aliases=["ls"], help="List sessions") |
| | p_list.add_argument("-g", "--global", dest="glob", action="store_true", help="Search all projects (default: current project only)") |
| | p_list.add_argument("--project", "-p", help="Filter by project name (substring match)") |
| | p_list.add_argument("--limit", "-n", type=int, help="Max sessions to show") |
| | p_list.add_argument("--date", "-d", help="Filter by date (e.g. 'yesterday', 'past 3 days', 'before may 5')") |
| | p_list.add_argument("--json", action="store_true", help="JSON output") |
| | p_list.add_argument("--pick", action="store_true", help="Interactive session picker") |
| | p_list.add_argument("--fzf", action="store_true", help="Use fzf for interactive picker") |
| | | | | # search |
| | p_search = sub.add_parser("search", aliases=["s", "grep"], help="Search conversations") |
| | p_search.add_argument("term", help="Search term (plain text or regex with -E)") |
| | p_search.add_argument("-g", "--global", dest="glob", action="store_true", help="Search all projects (default: current project only)") |
| | p_search.add_argument("--regex", "-E", action="store_true", help="Treat term as a regex pattern") |
| | p_search.add_argument("--fuzzy", "-F", action="store_true", help="Fuzzy match (typo-tolerant search)") |
| | p_search.add_argument("--project", "-p", help="Filter by project") |
| | p_search.add_argument("--date", "-d", help="Filter by date (e.g. 'two days ago', 'in the past week')") |
| | p_search.add_argument("--context", "-C", type=int, default=1, help="Lines of context around match") |
| | p_search.add_argument("--timeout", "-T", type=int, default=None, help="Timeout in seconds (default: 10 for fuzzy, unlimited otherwise)") |
| | p_search.add_argument("--json", action="store_true", help="JSON output") |
| | | | | # read |
| | p_read = sub.add_parser("read", aliases=["r", "show"], help="Read a session") |
| | p_read.add_argument("session_id", nargs="?", default=None, help="Session ID (prefix match OK, omit for picker)") |
| | p_read.add_argument("-g", "--global", dest="glob", action="store_true", help="Pick from all projects (default: current project only)") |
| | p_read.add_argument("--ai", action="store_true", help="Show only the last AI message") |
| | p_read.add_argument("--human", action="store_true", help="Show only the last human message") |
| | p_read.add_argument("--git", action="store_true", help="Show git commits from the session") |
| | p_read.add_argument("--full", action="store_true", help="Show full unabridged content (including diffs/tool output)") |
| | p_read.add_argument("--raw", action="store_true", help="Show raw content (JSON)") |
| | p_read.add_argument("--no-tools", action="store_true", help="Hide tool_use/tool_result blocks") |
| | p_read.add_argument("--all-tools", dest="all_tools", action="store_true", |
| | help="Show every tool_use with full input and every tool_result in full") | | | p_read.add_argument("--fzf", action="store_true", help="Use fzf for interactive picker") | | | | | | # summary | | | p_summary = sub.add_parser("summary", help="Summary of recent sessions, files, and commits") |
| | p_summary.add_argument("-g", "--global", dest="glob", action="store_true", help="Include all projects") |
| | p_summary.add_argument("--limit", "-n", type=int, default=5, help="Number of recent sessions (default: 5)") |
| | | | | # tools |
| | p_tools = sub.add_parser("tools", aliases=["t", "calls"], help="List tool/MCP calls in a session") |
| | p_tools.add_argument("session_id", help="Session ID (prefix match OK)") |
| | p_tools.add_argument("--mcp-only", action="store_true", help="Only show MCP tool calls") |
| | p_tools.add_argument("--no-bash", action="store_true", help="Hide shell (Bash/PowerShell) tool calls") |
| | p_tools.add_argument("--summary", action="store_true", help="Show call count summary only") |
| | p_tools.add_argument("--json", action="store_true", help="JSON output") |
| | | | | # files |
| | p_files = sub.add_parser("files", aliases=["f"], help="List files accessed in a session") |
| | p_files.add_argument("session_id", help="Session ID (prefix match OK)") |
| | p_files.add_argument("--images", action="store_true", help="Only show image files") |
| | p_files.add_argument("--code", action="store_true", help="Only show code files") |
| | p_files.add_argument("--data", action="store_true", help="Only show data files (csv, json, etc.)") |
| | p_files.add_argument("--docs", action="store_true", help="Only show document files") |
| | p_files.add_argument("--config", action="store_true", help="Only show config files") |
| | p_files.add_argument("--misc", action="store_true", help="Only show uncategorized files") |
| | p_files.add_argument("--json", action="store_true", help="JSON output") |
| | | | | # index | | | sub.add_parser("index", help="Build search term index (speeds up zsh session completion)") | | | | | | # projects | | | sub.add_parser("projects", aliases=["p"], help="List projects") | | | | | | # stats | | | sub.add_parser("stats", help="Show stats") | | | | | | # completions | | | p_comp = sub.add_parser("completions", help="Generate shell completions") |
| | p_comp.add_argument("shell", nargs="?", default=None, choices=["zsh", "bash", "fish", "powershell"], |
| | help="Shell type (auto-detected if omitted)") |
| | |
| | # Exit quietly when piped into head etc. (no SIGPIPE on Windows) |
| | if hasattr(signal, "SIGPIPE"): |
| | signal.signal(signal.SIGPIPE, signal.SIG_DFL) |
| | |
| | # Don't crash on characters the console/pipe encoding can't represent (e.g. cp1252 on Windows) |
| | for stream in (sys.stdout, sys.stderr): |
| | try: |
| | stream.reconfigure(errors="replace") |
| | except (AttributeError, ValueError): |
| | pass | | | | | | args = parser.parse_args() | | | |
| | if args.command not in (None, "completions") and not PROJECTS_DIR.is_dir(): |
| | print(f"No Claude Code history found at {PROJECTS_DIR}", file=sys.stderr) |
| | print("Set CLAUDE_CONFIG_DIR if your Claude config lives elsewhere.", file=sys.stderr) | | | sys.exit(1) | | | |
| | if args.command in ("list", "ls"): |
| | cmd_list(args) |
| | elif args.command in ("search", "s", "grep"): |
| | cmd_search(args) |
| | elif args.command in ("read", "r", "show"): |
| | cmd_read(args) |
| | elif args.command == "summary": |
| | cmd_summary(args) |
| | elif args.command in ("tools", "t", "calls"): |
| | cmd_tools(args) |
| | elif args.command in ("files", "f"): |
| | cmd_files(args) |
| | elif args.command == "index": |
| | cmd_index(args) |
| | elif args.command in ("projects", "p"): |
| | cmd_projects(args) |
| | elif args.command == "stats": |
| | cmd_stats(args) |
| | elif args.command == "completions": |
| | cmd_completions(args) |
| | else: | | | parser.print_help() | | | | | | |
| | if __name__ == "__main__": |
| | main() |