@antonior/claude-code-setup 1.0.1 → 1.1.0

package/README.md

@@ -18,13 +18,16 @@ That's it. The installer is idempotent — safe to re-run to pull updates.
 
 **macOS only.** The hooks and statusline use macOS-native tools (`afplay` for sound, BSD `date -r`, Homebrew for `jq`). On Linux/Windows the installer runs but the sound and statusline-clock features won't work.
 
-## Prerequisites
+## Dependencies (auto-installed via Homebrew)
 
-| Tool | Required? | Notes |
-|------|-----------|-------|
-| `jq` | **Yes** | Hooks parse JSON with it. Auto-installed via Homebrew if missing. |
-| `git` | Optional | Commit-scan and verify hooks no-op outside a git repo. |
-| `eslint` / `tsc` | Optional | Auto-fix and verify hooks no-op if not in `node_modules`. |
+The installer installs these for you if missing:
+
+| Tool | For | Notes |
+|------|-----|-------|
+| `jq` | hooks (JSON parsing) | **Required** — install aborts without it. |
+| `python3` | `transcript-search` MCP + video-FPS hook | Best-effort — feature stays dormant if it can't install. |
+| `ffmpeg` | `claude-video-vision` MCP | Best-effort. |
+| `git`, `eslint`, `tsc` | commit-scan / lint / typecheck hooks | Optional — hooks no-op cleanly when absent. |
 
 ## What it installs (into `~/.claude/`)
 
@@ -38,24 +41,28 @@ That's it. The installer is idempotent — safe to re-run to pull updates.
   - `stop-verify.sh` — lint + typecheck changed files when a turn ends
   - `notify-sound.sh` — sound on notification/stop
 - **`commands/`** — `/check-dep`, `/debug`, `/scan-secrets` slash commands
-- **`skills/`** — `/mute`, `/unmute`
+- **`skills/`** — `/mute`, `/unmute`, and `/caveman` (with intensity levels)
 - **`statusline.sh`** — git, model, context %, rate-limit statusline
+- **`transcript-search/rag_lite.py`** — the transcript-search MCP engine
+- **MCP servers** (registered via `claude mcp add-json`, user scope) — see below
+
+## Bundled MCP servers
 
-## Optional MCP servers
+Both are installed and auto-registered for you:
 
-`CLAUDE.md` references two MCP servers that are **not bundled** (they need their own setup). Without them, the related instructions simply don't fire:
+- **`transcript-search`** — full-text search over your *own* past Claude Code transcripts ("we talked about…", "like last time"). Pure-Python, stdlib only. The index is built **locally on your machine** from `~/.claude/projects/` on first run — nothing about your conversations is ever shipped in this package.
+- **`claude-video-vision`** — lets Claude watch/analyse videos (frames via `ffmpeg`). Published as [`claude-video-vision`](https://www.npmjs.com/package/claude-video-vision) on npm; run via `npx`.
 
-- **`transcript-search`** — powers the "past conversations are indexed" behaviour
-- **`claude-video-vision`** — video analysis
+## On a new machine — two one-time steps
 
-Install these separately if you want the full experience.
+The installer reproduces **100% of the configuration and behaviour**. Two things are *identity and secrets*, not config, and can never live in a public package — you set them once:
 
-## Notes on the shared config
+1. **Log into Claude Code** (your account — you'd do this on any new machine anyway).
+2. **Give `claude-video-vision` your own API key** if you use video analysis.
 
-Two items from my personal setup are intentionally **stripped** from the published version:
+## Intentionally not shipped
 
-- `skipDangerousModePermissionPrompt` — I won't disable a safety prompt on your machine.
-- The video-FPS `UserPromptSubmit` hook — it depends on `python3` and an unbundled MCP server.
+- `skipDangerousModePermissionPrompt` — this disables a safety confirmation. I won't flip that on your machine by default; enable it yourself if you want it.
 
 ## License
 

package/bin/install.js

@@ -44,28 +44,79 @@ function makeExecutable(filePath) {
   fs.chmodSync(filePath, '755');
 }
 
-function checkJq() {
-  const r = spawnSync('which', ['jq'], { encoding: 'utf8' });
-  return r.status === 0;
+// Is a command resolvable on PATH? (uses `command -v` via a shell so it sees
+// the same PATH the user's tools do, not just the bare which builtin.)
+function have(cmd) {
+  return spawnSync('bash', ['-lc', `command -v ${cmd}`], { encoding: 'utf8' }).status === 0;
 }
 
-function installJq() {
-  const hasBrew = spawnSync('which', ['brew'], { encoding: 'utf8' }).status === 0;
-  if (!hasBrew) {
-    fail('jq not found and Homebrew not installed.');
-    console.log(c.yellow('  Install jq manually: https://stedolan.github.io/jq/download/'));
+function hasBrew() {
+  return have('brew');
+}
+
+// Install a Homebrew formula. `required:true` → return false on failure so the
+// caller can abort; `required:false` → best-effort, warn and continue (the
+// related feature just stays dormant until the user installs it).
+function brewInstall(pkg, { required = false } = {}) {
+  if (have(pkg)) { ok(`${pkg} present`); return true; }
+  if (!hasBrew()) {
+    const m = `${pkg} not found and Homebrew not installed.`;
+    if (required) { fail(m); console.log(c.yellow(`  Install Homebrew (https://brew.sh) then re-run, or install ${pkg} manually.`)); return false; }
+    warn(`${m} Skipping — install it later for the related feature.`);
     return false;
   }
-  console.log(c.yellow('  Installing jq via Homebrew...'));
-  const r = spawnSync('brew', ['install', 'jq'], { stdio: 'inherit' });
+  console.log(c.yellow(`  Installing ${pkg} via Homebrew...`));
+  const r = spawnSync('brew', ['install', pkg], { stdio: 'inherit' });
   if (r.status !== 0) {
-    fail('brew install jq failed. Install manually.');
+    if (required) { fail(`brew install ${pkg} failed. Install manually.`); return false; }
+    warn(`brew install ${pkg} failed — continuing without it.`);
     return false;
   }
-  ok('jq installed');
+  ok(`${pkg} installed`);
   return true;
 }
 
+// Register the MCP servers via the official `claude` CLI (writes to user scope,
+// the same place they already live). Idempotent: skip any server already
+// registered. SECURITY: env is always {} — never serialize the user's real
+// environment or read ~/.claude.json (it holds the OAuth token).
+function registerMcpServers() {
+  if (!have('claude')) {
+    warn('`claude` CLI not on PATH — skipping MCP registration.');
+    info('  After installing Claude Code, register them manually:');
+    info(`    claude mcp add-json transcript-search '{"type":"stdio","command":"python3","args":["${path.join(CLAUDE_DIR, 'transcript-search', 'rag_lite.py')}","serve"],"env":{}}' --scope user`);
+    info("    claude mcp add claude-video-vision --scope user -- npx claude-video-vision");
+    return;
+  }
+  const existing = spawnSync('bash', ['-lc', 'claude mcp list'], { encoding: 'utf8', timeout: 60000 }).stdout || '';
+  const servers = [
+    {
+      name: 'transcript-search',
+      json: JSON.stringify({
+        type: 'stdio',
+        command: 'python3',
+        args: [path.join(CLAUDE_DIR, 'transcript-search', 'rag_lite.py'), 'serve'],
+        env: {},
+      }),
+    },
+    {
+      name: 'claude-video-vision',
+      json: JSON.stringify({
+        type: 'stdio',
+        command: 'npx',
+        args: ['claude-video-vision'],
+        env: {},
+      }),
+    },
+  ];
+  for (const s of servers) {
+    if (existing.includes(s.name)) { info(`MCP ${s.name} already registered — skipped`); continue; }
+    const r = spawnSync('claude', ['mcp', 'add-json', s.name, s.json, '--scope', 'user'], { encoding: 'utf8', timeout: 60000 });
+    if (r.status === 0) ok(`MCP ${s.name} registered`);
+    else warn(`MCP ${s.name} registration failed: ${(r.stderr || '').trim() || 'unknown error'}`);
+  }
+}
+
 function mergeSettings(existingPath, incomingPath) {
   const existing = JSON.parse(fs.readFileSync(existingPath, 'utf8'));
   const incoming = JSON.parse(fs.readFileSync(incomingPath, 'utf8'));
@@ -104,20 +155,22 @@ function mergeSettings(existingPath, incomingPath) {
 function main() {
   console.log(c.bold('\nclaude-code-setup — installing Antonio\'s Claude config\n'));
 
-  // 1. Check jq
-  if (!checkJq()) {
-    warn('jq not found — required by hooks');
-    const ok2 = installJq();
-    if (!ok2) process.exit(1);
-  } else {
-    ok('jq present');
-  }
+  // 1. Dependencies
+  //    jq is required (hooks parse JSON with it). python3 powers the
+  //    transcript-search MCP server; ffmpeg powers claude-video-vision —
+  //    both best-effort (feature stays dormant if absent).
+  console.log(c.bold('Dependencies:'));
+  if (!brewInstall('jq', { required: true })) process.exit(1);
+  brewInstall('python3');
+  brewInstall('ffmpeg');
 
   // 2. Ensure dirs
   ensureDir(CLAUDE_DIR);
   ensureDir(path.join(CLAUDE_DIR, 'hooks'));
   ensureDir(path.join(CLAUDE_DIR, 'skills'));
+  ensureDir(path.join(CLAUDE_DIR, 'skills', 'caveman'));
   ensureDir(path.join(CLAUDE_DIR, 'commands'));
+  ensureDir(path.join(CLAUDE_DIR, 'transcript-search'));
 
   // 3. Hooks
   const hooks = ['caveman-activate.sh', 'check-dep.sh', 'eslint-fix.sh', 'notify-sound.sh', 'scan-secrets.sh', 'stop-verify.sh'];
@@ -127,16 +180,21 @@ function main() {
     makeExecutable(dest);
   }
 
-  // 4. Skills
+  // 4. Skills (mute/unmute + the caveman /caveman skill with intensity levels)
   for (const s of ['mute.md', 'unmute.md']) {
     copyFile(path.join(FILES_DIR, 'skills', s), path.join(CLAUDE_DIR, 'skills', s), { skipIfExists: true });
   }
+  copyFile(path.join(FILES_DIR, 'skills', 'caveman', 'SKILL.md'), path.join(CLAUDE_DIR, 'skills', 'caveman', 'SKILL.md'), { skipIfExists: true });
 
   // 4b. Commands (slash commands referenced by CLAUDE.md)
   for (const cmd of ['check-dep.md', 'debug.md', 'scan-secrets.md']) {
     copyFile(path.join(FILES_DIR, 'commands', cmd), path.join(CLAUDE_DIR, 'commands', cmd), { skipIfExists: true });
   }
 
+  // 4c. transcript-search engine (the MCP server script — index.db is built
+  //     per-user from their own ~/.claude/projects and is never shipped)
+  copyFile(path.join(FILES_DIR, 'transcript-search', 'rag_lite.py'), path.join(CLAUDE_DIR, 'transcript-search', 'rag_lite.py'));
+
   // 5. Statusline
   const statuslineDest = path.join(CLAUDE_DIR, 'statusline.sh');
   copyFile(path.join(FILES_DIR, 'statusline.sh'), statuslineDest);
@@ -168,7 +226,14 @@ function main() {
     copyFile(path.join(FILES_DIR, 'settings.json'), settingsDest);
   }
 
-  console.log(c.bold(c.green('\nDone. Restart Claude Code to apply.\n')));
+  // 8. MCP servers (transcript-search + claude-video-vision)
+  console.log(c.bold('\nMCP servers:'));
+  registerMcpServers();
+
+  console.log(c.bold(c.green('\nDone. Restart Claude Code to apply.')));
+  console.log(c.dim('Two one-time steps on a new machine (identity, not config — they can\'t ship):'));
+  console.log(c.dim('  1. Log into Claude Code.'));
+  console.log(c.dim('  2. For video analysis, give claude-video-vision your own API key.\n'));
 }
 
 main();

package/files/settings.json

@@ -32,7 +32,10 @@
       "Bash(sw_vers:*)",
       "Bash(date)",
       "Bash(npm view:*)",
-      "Bash(npm ls:*)"
+      "Bash(npm ls:*)",
+      "Bash(claude update *)",
+      "Bash(python3 -c \"import sys,json; d=json.load\\(sys.stdin\\); print\\(json.dumps\\({k: d.get\\(k\\) for k in ['dependencies','devDependencies']}, indent=2\\)\\)\")",
+      "Bash(python3 -c \"import sys,json; d=json.load\\(sys.stdin\\); print\\(json.dumps\\(d.get\\('mcpServers', {}\\), indent=2\\)\\)\")"
     ]
   },
   "model": "sonnet",
@@ -117,6 +120,17 @@
         ]
       }
     ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 -c \"\nimport json, sys, re\ndata = json.load(sys.stdin)\nmsg = data.get('message', '')\nis_video = (bool(re.search(r'(?i)(analys[ei]|watch|summariz|process|review|transcript)', msg)) and bool(re.search(r'(?i)(\\\\.(mp4|mov|avi|mkv|webm)|youtube\\\\.com|youtu\\\\.be|video)', msg))) or bool(re.search(r'https?://(www\\\\.)?(youtube\\\\.com/watch|youtu\\\\.be/)', msg))\nhas_fps = bool(re.search(r'(?i)(\\\\bfps\\\\b|\\\\d+\\\\s*fps|frame.{0,2}rate|frames.{0,3}per.{0,3}second)', msg))\nif is_video and not has_fps:\n    print(json.dumps({'hookSpecificOutput': {'hookEventName': 'UserPromptSubmit', 'additionalContext': 'REMINDER: User wants to analyse a video but has NOT specified FPS. Before calling any video tools, ask them: How many FPS would you like to use? (default: auto)'}}))\n\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
     "Stop": [
       {
         "hooks": [

package/files/skills/caveman/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: caveman
+description: >
+  Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman
+  while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra,
+  wenyan-lite, wenyan-full, wenyan-ultra.
+  Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens",
+  "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.
+---
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure. Off only: "stop caveman" / "normal mode".
+
+Default: **full**. Switch: `/caveman lite|full|ultra`.
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **lite** | No filler/hedging. Keep articles + full sentences. Professional but tight |
+| **full** | Drop articles, fragments OK, short synonyms. Classic caveman |
+| **ultra** | Abbreviate prose words (DB/auth/config/req/res/fn/impl), strip conjunctions, arrows for causality (X → Y), one word when one word enough. Code symbols, function names, API names, error strings: never abbreviate |
+| **wenyan-lite** | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
+| **wenyan-full** | Maximum classical terseness. Fully 文言文. 80-90% character reduction. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其) |
+| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse |
+
+Example — "Why React component re-render?"
+- lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
+- full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
+- ultra: "Inline obj prop → new ref → re-render. `useMemo`."
+
+Example — "Explain database connection pooling."
+- lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
+- full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
+- ultra: "Pool = reuse DB conn. Skip handshake → fast under load."
+
+## Auto-Clarity
+
+Drop caveman when:
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity
+- User asks to clarify or repeats question
+
+Resume caveman after clear part done.
+
+## Boundaries
+
+Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Level persist until changed or session end.

package/files/transcript-search/rag_lite.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""Lightweight transcript search for Claude Code.
+
+SQLite FTS5 full-text index over past conversation transcripts in
+~/.claude/projects/**/*.jsonl. No embeddings, no daemons, no extra deps —
+pure Python stdlib. Indexes human prompts + assistant text only (tool output,
+thinking, and system noise are skipped to keep the signal high).
+
+Usage:
+  python3 rag_lite.py index                 # build / refresh the index
+  python3 rag_lite.py search "query" [n]    # search from the CLI
+  python3 rag_lite.py stats                 # row / file counts
+  python3 rag_lite.py serve                 # run as an MCP stdio server
+"""
+import os
+import sys
+import json
+import glob
+import sqlite3
+import re
+
+HOME = os.path.expanduser("~")
+PROJ_DIR = os.path.join(HOME, ".claude", "projects")
+DB_DIR = os.path.join(HOME, ".claude", "transcript-search")
+DB_PATH = os.path.join(DB_DIR, "index.db")
+
+
+# ---------------------------------------------------------------- storage
+def db():
+    os.makedirs(DB_DIR, exist_ok=True)
+    conn = sqlite3.connect(DB_PATH)
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute(
+        "CREATE VIRTUAL TABLE IF NOT EXISTS chunks USING fts5("
+        "text, role UNINDEXED, session UNINDEXED, project UNINDEXED, "
+        "branch UNINDEXED, ts UNINDEXED, file UNINDEXED, line UNINDEXED, "
+        "tokenize='porter unicode61')"
+    )
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS files("
+        "path TEXT PRIMARY KEY, size INTEGER, mtime REAL, lines INTEGER)"
+    )
+    return conn
+
+
+# ---------------------------------------------------------------- parsing
+def extract(obj):
+    """Return (role, text) for indexable turns, else None.
+
+    Indexes: user string prompts, assistant text blocks.
+    Skips: tool_use / tool_result payloads, thinking, and everything else.
+    """
+    t = obj.get("type")
+    if t not in ("user", "assistant"):
+        return None
+    m = obj.get("message") or {}
+    role = m.get("role") or t
+    cont = m.get("content")
+    parts = []
+    if isinstance(cont, str):
+        if role != "user":
+            return None
+        parts.append(cont)
+    elif isinstance(cont, list):
+        if role != "assistant":
+            return None  # list content on a user turn = tool results -> skip
+        for b in cont:
+            if isinstance(b, dict) and b.get("type") == "text" and b.get("text"):
+                parts.append(b["text"])
+    text = "\n".join(p for p in parts if p).strip()
+    if not text:
+        return None
+    # Drop local-command / system-reminder wrappers — pure noise for recall.
+    if text.startswith("<local-command") or text.startswith("Caveat:"):
+        return None
+    return role, text[:20000]
+
+
+# ---------------------------------------------------------------- indexing
+def index_file(conn, path):
+    st = os.stat(path)
+    row = conn.execute(
+        "SELECT size, mtime, lines FROM files WHERE path=?", (path,)
+    ).fetchone()
+    start = 0
+    if row:
+        size, mtime, lines = row
+        if size == st.st_size and mtime == st.st_mtime:
+            return 0  # unchanged
+        if st.st_size >= size:
+            start = lines  # append-only growth: skip already-indexed lines
+        else:
+            conn.execute("DELETE FROM chunks WHERE file=?", (path,))  # rewritten
+    added = 0
+    ln = -1
+    with open(path, "r", encoding="utf-8", errors="replace") as fh:
+        for ln, line in enumerate(fh):
+            if ln < start:
+                continue
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except Exception:
+                continue
+            ex = extract(obj)
+            if not ex:
+                continue
+            role, text = ex
+            cwd = obj.get("cwd") or ""
+            project = os.path.basename(cwd) if cwd else os.path.basename(os.path.dirname(path))
+            conn.execute(
+                "INSERT INTO chunks(text,role,session,project,branch,ts,file,line) "
+                "VALUES(?,?,?,?,?,?,?,?)",
+                (text, role, obj.get("sessionId") or os.path.basename(path),
+                 project, obj.get("gitBranch") or "", obj.get("timestamp") or "",
+                 path, ln),
+            )
+            added += 1
+    conn.execute(
+        "INSERT INTO files(path,size,mtime,lines) VALUES(?,?,?,?) "
+        "ON CONFLICT(path) DO UPDATE SET size=excluded.size, mtime=excluded.mtime, lines=excluded.lines",
+        (path, st.st_size, st.st_mtime, ln + 1),
+    )
+    return added
+
+
+def index_all(conn):
+    total = 0
+    for path in glob.glob(os.path.join(PROJ_DIR, "*", "*.jsonl")):
+        try:
+            total += index_file(conn, path)
+        except Exception:
+            pass
+    conn.commit()
+    return total
+
+
+# ---------------------------------------------------------------- search
+def fts_query(q):
+    toks = re.findall(r"[\w']+", q or "")
+    toks = [t for t in toks if len(t) > 1 or t.isdigit()]
+    if not toks:
+        return None
+    return " OR ".join('"%s"' % t.replace('"', '""') for t in toks)
+
+
+def search(conn, query, limit=8, project=None):
+    fq = fts_query(query)
+    if not fq:
+        return []
+    sql = ("SELECT snippet(chunks,0,'»','«',' … ',16), role, session, project, "
+           "branch, ts, file, line FROM chunks WHERE chunks MATCH ?")
+    args = [fq]
+    if project:
+        sql += " AND project=?"
+        args.append(project)
+    sql += " ORDER BY bm25(chunks) LIMIT ?"
+    args.append(int(limit))
+    return conn.execute(sql, args).fetchall()
+
+
+def get_context(path, line, before=3, after=3):
+    lo, hi = max(0, int(line) - before), int(line) + after
+    out = []
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as fh:
+            for i, l in enumerate(fh):
+                if i < lo:
+                    continue
+                if i > hi:
+                    break
+                try:
+                    o = json.loads(l)
+                except Exception:
+                    continue
+                ex = extract(o)
+                if ex:
+                    out.append((i, ex[0], ex[1][:1800]))
+    except OSError:
+        pass
+    return out
+
+
+def fmt_results(rows):
+    if not rows:
+        return "No matches."
+    out = []
+    for snip, role, _session, project, branch, ts, path, line in rows:
+        date = (ts or "")[:10] or "?"
+        br = branch or "-"
+        snip = re.sub(r"\s+", " ", snip).strip()
+        out.append(f"[{project} · {br} · {date} · {role}]  {path}:{line}\n  {snip}")
+    out.append("\nUse get_context(file, line) for the full surrounding turns.")
+    return "\n\n".join(out)
+
+
+def fmt_context(rows):
+    if not rows:
+        return "No context found at that location."
+    return "\n\n".join(f"--- line {i} ({role}) ---\n{text}" for i, role, text in rows)
+
+
+# ---------------------------------------------------------------- MCP server
+TOOLS = [
+    {
+        "name": "search",
+        "description": (
+            "Full-text search over past Claude Code conversation transcripts "
+            "(human prompts + assistant replies) for this and other projects. "
+            "Use when the user references past work ('we talked about', 'remember "
+            "when', 'like last time') or you need a prior decision/context."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Search terms."},
+                "limit": {"type": "integer", "description": "Max results (default 8)."},
+                "project": {"type": "string", "description": "Optional: restrict to a project folder name."},
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "get_context",
+        "description": "Return the surrounding conversation turns around a transcript hit (use the file+line from a search result).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "file": {"type": "string"},
+                "line": {"type": "integer"},
+                "before": {"type": "integer"},
+                "after": {"type": "integer"},
+            },
+            "required": ["file", "line"],
+        },
+    },
+]
+
+
+def _send(obj):
+    sys.stdout.write(json.dumps(obj) + "\n")
+    sys.stdout.flush()
+
+
+def _reply(mid, result):
+    _send({"jsonrpc": "2.0", "id": mid, "result": result})
+
+
+def _error(mid, code, message):
+    _send({"jsonrpc": "2.0", "id": mid, "error": {"code": code, "message": message}})
+
+
+def serve():
+    conn = db()
+    try:
+        index_all(conn)
+    except Exception:
+        pass
+    for raw in sys.stdin:
+        raw = raw.strip()
+        if not raw:
+            continue
+        try:
+            msg = json.loads(raw)
+        except Exception:
+            continue
+        method = msg.get("method")
+        mid = msg.get("id")
+        if method == "initialize":
+            ver = (msg.get("params") or {}).get("protocolVersion", "2025-06-18")
+            _reply(mid, {
+                "protocolVersion": ver,
+                "capabilities": {"tools": {}},
+                "serverInfo": {"name": "transcript-search", "version": "1.0.0"},
+            })
+        elif method in ("notifications/initialized", "notifications/cancelled"):
+            continue  # notifications: no response
+        elif method == "ping":
+            _reply(mid, {})
+        elif method == "tools/list":
+            _reply(mid, {"tools": TOOLS})
+        elif method == "tools/call":
+            p = msg.get("params") or {}
+            name = p.get("name")
+            a = p.get("arguments") or {}
+            try:
+                if name == "search":
+                    index_all(conn)
+                    text = fmt_results(search(conn, a.get("query", ""),
+                                              a.get("limit", 8), a.get("project")))
+                elif name == "get_context":
+                    text = fmt_context(get_context(a.get("file", ""), a.get("line", 0),
+                                                   a.get("before", 3), a.get("after", 3)))
+                else:
+                    _error(mid, -32601, "unknown tool: %s" % name)
+                    continue
+                _reply(mid, {"content": [{"type": "text", "text": text}]})
+            except Exception as e:
+                _reply(mid, {"content": [{"type": "text", "text": "error: %s" % e}], "isError": True})
+        elif mid is not None:
+            _error(mid, -32601, "method not found: %s" % method)
+
+
+# ---------------------------------------------------------------- CLI
+def main():
+    cmd = sys.argv[1] if len(sys.argv) > 1 else "serve"
+    if cmd == "serve":
+        serve()
+    elif cmd == "index":
+        conn = db()
+        n = index_all(conn)
+        print("indexed %d new turns" % n)
+    elif cmd == "stats":
+        conn = db()
+        index_all(conn)
+        rows = conn.execute("SELECT COUNT(*) FROM chunks").fetchone()[0]
+        files = conn.execute("SELECT COUNT(*) FROM files").fetchone()[0]
+        projs = conn.execute("SELECT project, COUNT(*) FROM chunks GROUP BY project ORDER BY 2 DESC").fetchall()
+        print("turns: %d   files: %d" % (rows, files))
+        for pr, c in projs:
+            print("  %5d  %s" % (c, pr))
+    elif cmd == "search":
+        conn = db()
+        index_all(conn)
+        q = sys.argv[2] if len(sys.argv) > 2 else ""
+        n = int(sys.argv[3]) if len(sys.argv) > 3 else 8
+        print(fmt_results(search(conn, q, n)))
+    else:
+        print(__doc__)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@antonior/claude-code-setup",
-  "version": "1.0.1",
-  "description": "Install Antonio's Claude Code config: hooks, skills, statusline, and settings",
+  "version": "1.1.0",
+  "description": "Install Antonio's full Claude Code setup: hooks, slash commands, skills, statusline, settings, and MCP servers (transcript-search + video-vision)",
   "bin": {
     "claude-code-setup": "bin/install.js"
   },
@@ -14,7 +14,10 @@
     "claude-code",
     "anthropic",
     "config",
-    "setup"
+    "setup",
+    "mcp",
+    "hooks",
+    "dotfiles"
   ],
   "author": "Antonio Radosav <antonio.radosav@protonmail.com>",
   "license": "MIT",