@poulles/worktree-dashboard 0.1.0 → 0.2.0

package/.claude/hooks/log-prompt-start.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+# UserPromptSubmit hook — runs the moment a prompt is submitted, before Claude
+# does any work. Records the prompt as the worktree's CURRENT task so the
+# dashboard shows "what it's working on" live during the turn. Writes a
+# {kind:"start"} entry to the same central, per-branch log the Stop hook later
+# appends a {kind:"done"} summary to.
+#
+# Wired up in .claude/settings.json. Receives the payload as JSON on stdin:
+#   { prompt, cwd, session_id, transcript_path, hook_event_name }
+
+# Don't fire inside the Stop hook's headless summarizer call.
+[ "${WORKTREE_LOG_HOOK:-}" = "1" ] && exit 0
+
+input=$(cat)
+# Critical: UserPromptSubmit stdout is injected into Claude's context. Send all
+# of this script's output to the void so we only ever touch the log file.
+exec >/dev/null 2>&1
+
+command -v jq >/dev/null 2>&1 || exit 0
+
+prompt=$(printf '%s' "$input" | jq -r '.prompt // empty')
+cwd=$(printf '%s' "$input" | jq -r '.cwd // empty')
+[ -n "$prompt" ] || exit 0
+[ -n "$cwd" ] || cwd=$PWD
+
+cd "$cwd" 2>/dev/null || exit 0
+common=$(git rev-parse --git-common-dir 2>/dev/null) || exit 0
+main=$(dirname "$(cd "$common" && pwd)")
+branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo detached)
+safe=$(printf '%s' "$branch" | tr '/' '-')
+logdir="$main/.worktree-logs"
+mkdir -p "$logdir"
+
+# Keep the stored prompt compact — the dashboard only needs a glanceable line.
+prompt=$(printf '%s' "$prompt" | tr '\n' ' ' | cut -c1-500)
+
+jq -nc --arg b "$branch" --arg p "$prompt" \
+  '{ts: (now * 1000 | floor), branch: $b, kind: "start", prompt: $p}' >> "$logdir/$safe.jsonl"
+
+exit 0

package/.claude/hooks/log-prompt.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Stop hook — runs every time Claude finishes a turn.
+# Appends a one-line summary of the latest turn to a central, per-branch log in
+# the MAIN checkout, so every worktree's history lives in one shared, gitignored
+# place that the dashboard (which runs from main) can read.
+#
+# Wired up in .claude/settings.json. Receives the hook payload as JSON on stdin:
+#   { transcript_path, cwd, session_id, hook_event_name, stop_hook_active }
+
+# Guard: the summary itself is produced by a headless `claude` call, whose own
+# Stop hook would otherwise fire this script again — a fork bomb. Bail early when
+# we're already inside the summarizer.
+[ "${WORKTREE_LOG_HOOK:-}" = "1" ] && exit 0
+
+command -v jq >/dev/null 2>&1 || exit 0
+command -v claude >/dev/null 2>&1 || exit 0
+
+input=$(cat)
+transcript=$(printf '%s' "$input" | jq -r '.transcript_path // empty')
+cwd=$(printf '%s' "$input" | jq -r '.cwd // empty')
+[ -n "$transcript" ] && [ -f "$transcript" ] || exit 0
+[ -n "$cwd" ] || cwd=$PWD
+
+cd "$cwd" 2>/dev/null || exit 0
+common=$(git rev-parse --git-common-dir 2>/dev/null) || exit 0
+main=$(dirname "$(cd "$common" && pwd)")
+branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo detached)
+safe=$(printf '%s' "$branch" | tr '/' '-')
+logdir="$main/.worktree-logs"
+mkdir -p "$logdir"
+
+# Summarize + write asynchronously so we never add latency to the turn.
+(
+  # Files changed in the latest turn: tool_uses that come after the last *human*
+  # prompt (a user event whose content is text, not a tool_result).
+  files=$(jq -rs '
+    . as $all
+    | ([ range(0; ($all | length)) as $i
+         | select($all[$i].type == "user"
+                  and (($all[$i].message.content | type == "string")
+                       or (any($all[$i].message.content[]?; .type == "text")))) | $i ] | last) as $u
+    | [ $all[(($u // -1) + 1):][]
+        | select(.type == "assistant") | .message.content[]?
+        | select(.type == "tool_use" and (.name == "Write" or .name == "Edit" or .name == "NotebookEdit"))
+        | .input.file_path ] | unique
+  ' "$transcript" 2>/dev/null)
+  case "$files" in "" | null) files='[]' ;; esac
+
+  instr='Below is the tail of a Claude Code session transcript in JSONL. In ONE concise sentence (max ~20 words), summarize what the user most recently asked for and what was done in response. Reply with ONLY that sentence — no preamble, no quotes.'
+  body=$(tail -c 16000 "$transcript")
+
+  # Run the summarizer from a throwaway dir so its own session transcript lands
+  # in a separate ~/.claude/projects entry and never shadows the worktree's real
+  # session in the dashboard.
+  sdir="${TMPDIR:-/tmp}/worktree-log-summarizer"
+  mkdir -p "$sdir"
+  summary=$(cd "$sdir" && printf '%s\n\n%s\n' "$instr" "$body" \
+    | WORKTREE_LOG_HOOK=1 claude -p --model haiku 2>/dev/null \
+    | tr '\n' ' ' | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')
+  [ -n "$summary" ] || summary='(summary unavailable)'
+
+  jq -nc --arg b "$branch" --arg s "$summary" --argjson f "$files" \
+    '{ts: (now * 1000 | floor), branch: $b, kind: "done", summary: $s, files: $f}' >> "$logdir/$safe.jsonl"
+) >/dev/null 2>&1 &
+
+exit 0

package/README.md

@@ -17,7 +17,8 @@ npx @poulles/worktree-dashboard
 ## Usage
 
 ```bash
-worktree-dashboard [options]
+worktree-dashboard [options]   # start the dashboard
+worktree-dashboard init        # install prompt-logging hooks (see below)
 ```
 
 | Flag | Default | Description |
@@ -28,6 +29,28 @@ worktree-dashboard [options]
 | `--worktrees <path>` | `.claude/worktrees` | Path to the worktrees folder |
 | `--config <path>` | `.worktree-dashboard.json` | Path to a config file |
 
+## Prompt logging
+
+By default the dashboard shows each agent's live status. To also show **what each
+worktree was last asked to do** (a one-line summary per turn), install the logging hooks
+into your project:
+
+```bash
+npx @poulles/worktree-dashboard init
+```
+
+This copies two Claude Code hooks into `.claude/hooks/`, wires them into
+`.claude/settings.json` (existing settings are preserved), and adds `.worktree-logs/` to
+`.gitignore`. The hooks write a per-branch log on every prompt and turn; the dashboard
+reads those logs and shows the latest prompt/summary on each worktree card. Without this
+step, nothing creates `.worktree-logs/` and the prompt column stays empty.
+
+Notes:
+
+- Requires `jq` and the `claude` CLI on your PATH — summaries are generated by Claude.
+- Re-running `init` is safe; it won't duplicate hooks already present.
+- Restart any running Claude Code session afterward so it picks up the new hooks.
+
 ## Config file
 
 Create `.worktree-dashboard.json` in your project root. CLI flags override these values.
@@ -112,6 +135,7 @@ Each worktree card links to VS Code so you can jump straight to the relevant fil
 - Node.js 18+
 - git
 - VS Code with `code` on PATH
+- `jq` and the `claude` CLI — only for prompt logging (`worktree-dashboard init`)
 
 ## WSL
 

package/bin/cli.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-import { readFileSync, existsSync } from 'fs';
-import { resolve, join } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync, chmodSync } from 'fs';
+import { resolve, join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { spawn } from 'child_process';
 import { createServer } from '../src/server.mjs';
 
-const VERSION = '0.1.0';
+const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const VERSION = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8')).version;
 
 function parseArgs(argv) {
   const args = {};
@@ -50,6 +52,84 @@ function loadLogo(logoPath) {
   return `data:${mime};base64,${data}`;
 }
 
+// ── `init` command ──────────────────────────────────────────────────────────
+// Install the prompt-logging hooks into the current project so the dashboard can
+// show "what each worktree is working on". The dashboard only READS the logs in
+// `.worktree-logs/`; these Claude Code hooks are what create and write them.
+const HOOK_FILES = ['log-prompt-start.sh', 'log-prompt.sh'];
+const HOOK_EVENTS = {
+  UserPromptSubmit: '$CLAUDE_PROJECT_DIR/.claude/hooks/log-prompt-start.sh',
+  Stop: '$CLAUDE_PROJECT_DIR/.claude/hooks/log-prompt.sh',
+};
+
+// Ensure settings.hooks[event] contains a command entry, without clobbering any
+// existing hooks (including a previous run of this command).
+function ensureHook(settings, event, command) {
+  settings.hooks ??= {};
+  const groups = (settings.hooks[event] ??= []);
+  const already = groups.some(g => (g.hooks ?? []).some(h => h.command === command));
+  if (already) return false;
+  groups.push({ hooks: [{ type: 'command', command }] });
+  return true;
+}
+
+function ensureGitignore(target) {
+  const file = join(target, '.gitignore');
+  const entry = '.worktree-logs/';
+  const existing = existsSync(file) ? readFileSync(file, 'utf8') : '';
+  if (existing.split('\n').some(l => l.trim() === entry)) return false;
+  const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+  writeFileSync(file, `${existing}${prefix}${entry}\n`);
+  return true;
+}
+
+function init() {
+  const target = process.cwd();
+  const srcHooks = join(PKG_ROOT, '.claude/hooks');
+  const destHooks = join(target, '.claude/hooks');
+
+  if (!existsSync(join(srcHooks, HOOK_FILES[0]))) {
+    console.error(`  ✗ Could not find bundled hooks at ${srcHooks}`);
+    process.exit(1);
+  }
+
+  mkdirSync(destHooks, { recursive: true });
+  for (const f of HOOK_FILES) {
+    copyFileSync(join(srcHooks, f), join(destHooks, f));
+    chmodSync(join(destHooks, f), 0o755);
+  }
+  console.log(`  ✓ Installed hooks → ${join('.claude', 'hooks')}/`);
+
+  const settingsPath = join(target, '.claude/settings.json');
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    } catch (e) {
+      console.error(`  ✗ Could not parse ${settingsPath}: ${e.message}`);
+      console.error('    Fix or remove it, then re-run `worktree-dashboard init`.');
+      process.exit(1);
+    }
+  }
+  let added = false;
+  for (const [event, command] of Object.entries(HOOK_EVENTS)) {
+    added = ensureHook(settings, event, command) || added;
+  }
+  if (added) {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+    console.log(`  ✓ Wired hooks into ${join('.claude', 'settings.json')}`);
+  } else {
+    console.log(`  • Hooks already wired in ${join('.claude', 'settings.json')}`);
+  }
+
+  if (ensureGitignore(target)) console.log('  ✓ Added .worktree-logs/ to .gitignore');
+
+  console.log('\n  Prompt logging is set up. Notes:');
+  console.log('    • Requires `jq` and the `claude` CLI on your PATH (summaries use Claude).');
+  console.log('    • Restart any running Claude Code session to pick up the new hooks.');
+  console.log('    • Logs land in .worktree-logs/ in your main checkout.\n');
+}
+
 function openBrowser(url) {
   try {
     const procVersion = readFileSync('/proc/version', 'utf8').toLowerCase();
@@ -66,8 +146,31 @@ function openBrowser(url) {
   }
 }
 
+function printHelp() {
+  console.log(`
+  Worktree Dashboard (v${VERSION})
+
+  Usage:
+    worktree-dashboard [options]    Start the dashboard (default)
+    worktree-dashboard init         Install prompt-logging hooks into this project
+    worktree-dashboard --help       Show this help
+
+  Options:
+    --port <n>          Port to listen on (default 3333)
+    --title <text>      Dashboard title
+    --worktrees <path>  Worktrees directory (default .claude/worktrees)
+    --logo <path>       Path to a logo image
+    --config <path>     Path to a .worktree-dashboard.json config file
+`);
+}
+
 function main() {
-  const cliArgs = parseArgs(process.argv.slice(2));
+  const argv = process.argv.slice(2);
+  const command = argv[0];
+  if (command === 'init') return init();
+  if (command === '--help' || command === '-h' || command === 'help') return printHelp();
+
+  const cliArgs = parseArgs(argv);
   const fileConfig = loadFileConfig(cliArgs.configPath);
 
   const config = {

package/package.json

@@ -1,20 +1,36 @@
 {
   "name": "@poulles/worktree-dashboard",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A local dashboard for monitoring and managing git worktrees with Claude Code agents",
   "type": "module",
   "bin": {
     "worktree-dashboard": "./bin/cli.mjs"
   },
-  "files": ["bin", "src"],
-  "engines": { "node": ">=18" },
-  "keywords": ["claude-code", "worktree", "git", "dashboard", "developer-tools"],
+  "files": [
+    "bin",
+    "src",
+    ".claude/hooks"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "worktree",
+    "git",
+    "dashboard",
+    "developer-tools"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/gpoulles/worktree-dashboard.git"
   },
-  "bugs": { "url": "https://github.com/gpoulles/worktree-dashboard/issues" },
+  "bugs": {
+    "url": "https://github.com/gpoulles/worktree-dashboard/issues"
+  },
   "homepage": "https://github.com/gpoulles/worktree-dashboard#readme",
-  "publishConfig": { "access": "public" }
+  "publishConfig": {
+    "access": "public"
+  }
 }