@workscribe/cli 1.3.0 → 1.5.0

package/dist/index.js

@@ -173,6 +173,12 @@ function deleteEventsByIds(ids) {
     clearSessionsForDate(date);
   }
 }
+function deleteEventsForDate(date) {
+  const db = getDb();
+  clearSessionsForDate(date);
+  const result = db.prepare(`DELETE FROM events WHERE date(captured_at, 'localtime') = $date`).run({ date });
+  return result.changes;
+}
 function clearSessionsForDate(date) {
   const db = getDb();
   db.prepare(`
@@ -271,52 +277,72 @@ function getGitContext(cwd, nameOverride) {
   }
 }
 
-// src/capture/ai-tools.json
+// src/capture/git-snapshot.ts
+var import_child_process2 = require("child_process");
+function getCommitsSince(sha, cwd) {
+  if (!sha) return [];
+  try {
+    const out = (0, import_child_process2.execSync)(`git log ${sha}..HEAD --format=%s`, { cwd, timeout: 3e3 }).toString().trim();
+    return out ? out.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+// src/config/ai-tools.json
 var ai_tools_default = [
   {
     tool: "claude",
+    displayName: "Claude Code",
     pattern: "^claude\\b",
     hook: "claude-code",
     contextSource: "hook"
   },
   {
     tool: "aider",
+    displayName: "Aider",
     pattern: "^aider\\b",
     hook: null,
     contextSource: "history-file"
   },
   {
     tool: "gemini",
+    displayName: "Gemini",
     pattern: "^gemini\\b",
     hook: null,
     contextSource: null
   },
   {
     tool: "gh copilot",
+    displayName: "GitHub Copilot",
     pattern: "^gh\\s+copilot\\b",
     hook: null,
     contextSource: null
   },
   {
     tool: "cody",
+    displayName: "Cody",
     pattern: "^cody\\b",
     hook: null,
     contextSource: null
   },
   {
     tool: "amazon-q",
+    displayName: "Amazon Q",
     pattern: "^q\\s+(chat|dev)\\b",
     hook: null,
     contextSource: null
   },
   {
     tool: "continue",
+    displayName: "Continue",
     pattern: "^continue\\b",
     hook: null,
     contextSource: null
   },
   {
     tool: "cursor",
+    displayName: "Cursor",
     pattern: "^cursor\\b",
     hook: null,
     contextSource: null
@@ -378,6 +404,10 @@ var RULES = [
     tool: m[1],
     packages: extractPackages(cmd, "add")
   })),
+  makeRule(/^bun\s+(install|add)\b/, "dependency_install", (_m, cmd) => ({
+    tool: "bun",
+    packages: extractPackages(cmd, "add")
+  })),
   makeRule(/^pip\s+(install)\b/, "dependency_install", (_m, cmd) => ({
     tool: "pip",
     packages: extractPackages(cmd, "install")
@@ -403,12 +433,19 @@ var RULES = [
     tool: m[1],
     packages: extractPackages(cmd, "remove")
   })),
+  makeRule(/^bun\s+remove\b/, "dependency_remove", (_m, cmd) => ({
+    tool: "bun",
+    packages: extractPackages(cmd, "remove")
+  })),
   makeRule(/^pip\s+uninstall\b/, "dependency_remove", (_m, cmd) => ({
     tool: "pip",
     packages: extractPackages(cmd, "uninstall")
   })),
   // ─── Tests ────────────────────────────────────────────────────────────────
-  makeRule(/^(npm\s+(test|run\s+test)|yarn\s+test|pnpm\s+test)\b/, "test_run", () => ({ tool: "npm" })),
+  makeRule(/^npm\s+(test|run\s+test)\b/, "test_run", () => ({ tool: "npm" })),
+  makeRule(/^yarn\s+test\b/, "test_run", () => ({ tool: "yarn" })),
+  makeRule(/^pnpm\s+test\b/, "test_run", () => ({ tool: "pnpm" })),
+  makeRule(/^bun\s+test\b/, "test_run", () => ({ tool: "bun" })),
   makeRule(/^(jest|vitest)\b/, "test_run", (m) => ({ tool: m[1] })),
   makeRule(/^pytest\b/, "test_run", () => ({ tool: "pytest" })),
   makeRule(/^go\s+test\b/, "test_run", () => ({ tool: "go" })),
@@ -418,6 +455,7 @@ var RULES = [
   // ─── Build ────────────────────────────────────────────────────────────────
   makeRule(/^npm\s+run\s+build\b/, "build", () => ({ tool: "npm" })),
   makeRule(/^(yarn|pnpm)\s+build\b/, "build", (m) => ({ tool: m[1] })),
+  makeRule(/^bun\s+run\s+build\b/, "build", () => ({ tool: "bun" })),
   makeRule(/^(make|gmake)\b/, "build", (m) => ({ tool: m[1] })),
   makeRule(/^cargo\s+build\b/, "build", () => ({ tool: "cargo" })),
   makeRule(/^go\s+build\b/, "build", () => ({ tool: "go" })),
@@ -429,6 +467,10 @@ var RULES = [
     script: cmd.split(/\s+/)[2]
   })),
   makeRule(/^(yarn|pnpm)\s+(dev|start)\b/, "server_run", (m) => ({ tool: m[1], script: m[2] })),
+  makeRule(/^bun\s+run\s+(dev|start|serve)\b/, "server_run", (_m, cmd) => ({
+    tool: "bun",
+    script: cmd.split(/\s+/)[2]
+  })),
   makeRule(/^python\s+.*manage\.py\s+runserver\b/, "server_run", () => ({ tool: "django" })),
   // ─── Infrastructure ───────────────────────────────────────────────────────
   makeRule(/^ssh\b/, "infrastructure", (_m, cmd) => {
@@ -461,18 +503,36 @@ var RULES = [
     return { variable: varName };
   }),
   makeRule(/^source\s+/, "environment", () => ({})),
-  // ─── npm scripts (generic) ────────────────────────────────────────────────
+  // ─── generic run scripts ──────────────────────────────────────────────────
   makeRule(/^npm\s+run\s+\S+/, "script_run", (_m, cmd) => ({
     tool: "npm",
     script: cmd.split(/\s+/)[2]
   })),
+  makeRule(/^bun\s+run\s+\S+/, "script_run", (_m, cmd) => ({
+    tool: "bun",
+    script: cmd.split(/\s+/)[2]
+  })),
+  // ─── Code search ─────────────────────────────────────────────────────────
+  makeRule(/^(grep|egrep|fgrep)\b/, "code_search", (m) => ({ tool: m[1] })),
+  makeRule(/^(rg|ag|ack|ripgrep)\b/, "code_search", (m) => ({ tool: m[1] })),
+  makeRule(/^find\s/, "code_search", () => ({ tool: "find" })),
+  // ─── Code read ────────────────────────────────────────────────────────────
+  makeRule(/^(cat|bat|less|more)\s+\S+/, "code_read", (m) => ({ tool: m[1] })),
+  makeRule(/^(head|tail)\b/, "code_read", (m) => ({ tool: m[1] })),
+  // ─── File operations ──────────────────────────────────────────────────────
+  makeRule(/^(cp|rsync)\b/, "file_ops", (m) => ({ tool: m[1] })),
+  makeRule(/^(mv)\b/, "file_ops", () => ({ tool: "mv" })),
+  makeRule(/^(rm|rmdir)\b/, "file_ops", (m) => ({ tool: m[1] })),
+  makeRule(/^(mkdir|touch|ln)\b/, "file_ops", (m) => ({ tool: m[1] })),
+  makeRule(/^(chmod|chown|chgrp)\b/, "file_ops", (m) => ({ tool: m[1] })),
   // ─── AI terminal tools (registry-driven) ─────────────────────────────────
   ...ai_tools_default.map(
     (entry) => makeRule(new RegExp(entry.pattern), "ai_session", () => ({ tool: entry.tool }))
   )
 ];
 function normalizeCommand(command) {
-  const trimmed = command.trim().replace(/\s+/g, " ");
+  let trimmed = command.trim().replace(/\s+/g, " ");
+  trimmed = trimmed.replace(/^(git)\s+-C\s+\S+\s+/, "$1 ");
   for (const rule of RULES) {
     const result = rule.match(trimmed);
     if (result) return result;
@@ -563,12 +623,14 @@ function deepMerge(defaults, overrides) {
 function normalizeForFilter(cmd) {
   return cmd.trim().replace(/\s+/g, " ");
 }
+var BUILTIN_IGNORE = /* @__PURE__ */ new Set(["workscribe"]);
 function shouldFilter(command, ignoreList) {
   const normalized = normalizeForFilter(command);
   if (!normalized) return true;
+  const baseCmd = normalized.split(" ")[0];
+  if (BUILTIN_IGNORE.has(baseCmd)) return true;
   const normalizedIgnore = ignoreList.map(normalizeForFilter);
   if (normalizedIgnore.includes(normalized)) return true;
-  const baseCmd = normalized.split(" ")[0];
   if (normalizedIgnore.includes(baseCmd)) return true;
   return false;
 }
@@ -590,6 +652,10 @@ function captureCommand(opts) {
   const nameOverride = config.projects?.[cwd] ?? null;
   const { repoName, branch } = getGitContext(cwd, nameOverride);
   const { category, metadata } = normalizeCommand(safeCommand);
+  if (category === "ai_session" && opts.gitBefore) {
+    const commits = getCommitsSince(opts.gitBefore, cwd);
+    if (commits.length > 0) metadata.commits = commits;
+  }
   insertEvent({
     captured_at: (/* @__PURE__ */ new Date()).toISOString(),
     command: safeCommand,
@@ -626,14 +692,15 @@ function debugLog(context, error) {
 
 // src/cli/capture.ts
 function registerCapture(program2) {
-  program2.command("_capture").description("Internal: capture a shell command event (called by shell hook)").option("--cmd <command>", "command that was executed").option("--cwd <path>", "working directory").option("--exit <code>", "exit code", parseInt).option("--duration <ms>", "duration in milliseconds", parseInt).action((opts) => {
+  program2.command("_capture").description("Internal: capture a shell command event (called by shell hook)").option("--cmd <command>", "command that was executed").option("--cwd <path>", "working directory").option("--exit <code>", "exit code", parseInt).option("--duration <ms>", "duration in milliseconds", parseInt).option("--git-before <sha>", "git HEAD SHA before this command ran").action((opts) => {
     try {
       if (!opts.cmd || !opts.cwd) return;
       captureCommand({
         command: opts.cmd,
         cwd: opts.cwd,
         exitCode: opts.exit ?? null,
-        durationMs: opts.duration ?? null
+        durationMs: opts.duration ?? null,
+        gitBefore: opts.gitBefore ?? void 0
       });
     } catch (err) {
       debugLog("_capture", err);
@@ -641,22 +708,62 @@ function registerCapture(program2) {
   });
 }
 
+// src/cli/hook.ts
+function parseHookPayload(raw) {
+  if (!raw.trim()) return null;
+  const payload = JSON.parse(raw);
+  const toolInput = payload.tool_input;
+  const command = typeof toolInput?.command === "string" ? toolInput.command : null;
+  const cwd = typeof payload.cwd === "string" ? payload.cwd : null;
+  if (!command || !cwd) return null;
+  return { command, cwd };
+}
+function registerHook(program2) {
+  program2.command("_hook").description("Internal: capture events from AI tool hooks (stdin JSON payload)").option("--source <source>", "hook source identifier (e.g. claude-code)").action(() => {
+    let raw = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => {
+      try {
+        const parsed = parseHookPayload(raw);
+        if (!parsed) return;
+        captureCommand({ command: parsed.command, cwd: parsed.cwd, exitCode: null, durationMs: null });
+      } catch (err) {
+        debugLog("_hook", err);
+      }
+    });
+  });
+}
+
 // src/cli/init.ts
-var import_fs6 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var import_os2 = __toESM(require("os"));
+var import_fs8 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
 var import_prompts = __toESM(require("prompts"));
 var import_chalk2 = __toESM(require("chalk"));
+
+// src/capture/shell-hook.ts
+var import_fs6 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
 var HOOK_START = "# workscribe:hook:start";
-function detectShell() {
-  const shell = process.env.SHELL ?? "";
-  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path3.default.join(import_os2.default.homedir(), ".zshrc") };
-  if (shell.includes("bash")) return { name: "bash", rcFile: import_path3.default.join(import_os2.default.homedir(), ".bashrc") };
-  return null;
+var HOOK_END = "# workscribe:hook:end";
+function getInstalledHookBlock(rcFile) {
+  if (!import_fs6.default.existsSync(rcFile)) return null;
+  const content = import_fs6.default.readFileSync(rcFile, "utf-8");
+  const startIdx = content.indexOf(HOOK_START);
+  const endIdx = content.indexOf(HOOK_END);
+  if (startIdx === -1 || endIdx === -1) return null;
+  return content.slice(startIdx, endIdx + HOOK_END.length);
 }
 function isHookInstalled(rcFile) {
-  if (!import_fs6.default.existsSync(rcFile)) return false;
-  return import_fs6.default.readFileSync(rcFile, "utf-8").includes(HOOK_START);
+  return getInstalledHookBlock(rcFile) !== null;
+}
+function isHookOutdated(rcFile, hookContent) {
+  const installed = getInstalledHookBlock(rcFile);
+  if (!installed) return false;
+  return installed.trim() !== hookContent.trim();
 }
 function installHook(rcFile, hookContent) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
@@ -666,15 +773,98 @@ function installHook(rcFile, hookContent) {
 ${hookContent}
 `);
 }
+function updateHook(rcFile, hookContent) {
+  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
+  import_fs6.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path3.default.basename(backup)}`);
+  const content = import_fs6.default.readFileSync(rcFile, "utf-8");
+  const startIdx = content.indexOf(HOOK_START);
+  const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
+  import_fs6.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
+}
+
+// src/capture/hooks/claude-code.ts
+var import_fs7 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+
+// src/capture/hooks/utils.ts
+var import_child_process3 = require("child_process");
+function isCommandInstalled(cmd) {
+  try {
+    (0, import_child_process3.execSync)(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/capture/hooks/claude-code.ts
+var CLAUDE_SETTINGS_PATH = import_path4.default.join(import_os2.default.homedir(), ".claude", "settings.json");
+function readSettings() {
+  if (!import_fs7.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(import_fs7.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+var claudeCodeIntegration = {
+  displayName: "Claude Code",
+  isInstalled() {
+    return isCommandInstalled("claude");
+  },
+  isHookInstalled() {
+    const settings = readSettings();
+    const postToolUse = settings.hooks?.PostToolUse ?? [];
+    return postToolUse.some((entry) => {
+      const hooks = entry.hooks ?? [];
+      return hooks.some((h) => {
+        const hook = h;
+        return typeof hook.command === "string" && hook.command.includes("workscribe _hook");
+      });
+    });
+  },
+  install() {
+    const settings = readSettings();
+    const existingHooks = settings.hooks ?? {};
+    const existingPostToolUse = existingHooks.PostToolUse ?? [];
+    settings.hooks = {
+      ...existingHooks,
+      PostToolUse: [
+        ...existingPostToolUse,
+        {
+          matcher: "Bash",
+          hooks: [{ type: "command", command: "workscribe _hook --source claude-code", async: true }]
+        }
+      ]
+    };
+    import_fs7.default.mkdirSync(import_path4.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+    import_fs7.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  }
+};
+
+// src/capture/hooks/index.ts
+var AI_HOOK_INTEGRATIONS = {
+  "claude-code": claudeCodeIntegration
+};
+
+// src/cli/init.ts
+function detectShell() {
+  const shell = process.env.SHELL ?? "";
+  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path5.default.join(import_os3.default.homedir(), ".zshrc") };
+  if (shell.includes("bash")) return { name: "bash", rcFile: import_path5.default.join(import_os3.default.homedir(), ".bashrc") };
+  return null;
+}
 function registerInit(program2) {
-  program2.command("init").description("Install shell hooks and set up Workscribe").action(async () => {
+  program2.command("init").description("Set up Workscribe and install or update shell hooks").action(async () => {
     log.plain(import_chalk2.default.bold("\n  Workscribe \u2014 Developer Work Journal\n"));
-    if (!import_fs6.default.existsSync(WORKSCRIBE_DIR)) {
-      import_fs6.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
+    if (!import_fs8.default.existsSync(WORKSCRIBE_DIR)) {
+      import_fs8.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
       log.success(`Created ${WORKSCRIBE_DIR}`);
     } else {
       try {
-        import_fs6.default.chmodSync(WORKSCRIBE_DIR, 448);
+        import_fs8.default.chmodSync(WORKSCRIBE_DIR, 448);
       } catch {
       }
     }
@@ -685,17 +875,48 @@ function registerInit(program2) {
       log.warn("Could not detect shell. Supported: zsh, bash");
       log.plain(`Manually add the hook from: ${import_chalk2.default.cyan("shell/hook.zsh")} or ${import_chalk2.default.cyan("shell/hook.bash")}`);
     } else {
-      if (isHookInstalled(shell.rcFile)) {
-        log.info(`Shell hook already installed in ${shell.rcFile}`);
+      const hookFile = import_path5.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
+      if (!import_fs8.default.existsSync(hookFile)) {
+        log.warn(`Hook template not found at ${hookFile}`);
       } else {
-        const hookFile = import_path3.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
-        if (!import_fs6.default.existsSync(hookFile)) {
-          log.warn(`Hook template not found at ${hookFile}`);
-        } else {
-          const hookContent = import_fs6.default.readFileSync(hookFile, "utf-8");
-          if (!import_fs6.default.existsSync(shell.rcFile)) import_fs6.default.writeFileSync(shell.rcFile, "");
+        const hookContent = import_fs8.default.readFileSync(hookFile, "utf-8");
+        if (!import_fs8.default.existsSync(shell.rcFile)) import_fs8.default.writeFileSync(shell.rcFile, "");
+        if (!isHookInstalled(shell.rcFile)) {
           installHook(shell.rcFile, hookContent);
           log.success(`Shell hook installed in ${shell.rcFile}`);
+        } else if (isHookOutdated(shell.rcFile, hookContent)) {
+          const { update } = await (0, import_prompts.default)({
+            type: "confirm",
+            name: "update",
+            message: `Shell hook in ${shell.rcFile} is outdated. Update?`,
+            initial: true
+          });
+          if (update) {
+            updateHook(shell.rcFile, hookContent);
+            log.success(`Shell hook updated in ${shell.rcFile}`);
+          } else {
+            log.info("Shell hook update skipped");
+          }
+        } else {
+          log.info(`Shell hook up to date in ${shell.rcFile}`);
+        }
+      }
+    }
+    for (const tool of ai_tools_default.filter((t) => t.hook !== null)) {
+      const integration = AI_HOOK_INTEGRATIONS[tool.hook];
+      if (!integration?.isInstalled()) continue;
+      if (integration.isHookInstalled()) {
+        log.info(`${integration.displayName} session hook already installed`);
+      } else {
+        const { install } = await (0, import_prompts.default)({
+          type: "confirm",
+          name: "install",
+          message: `${integration.displayName} detected. Install session capture hook?`,
+          initial: true
+        });
+        if (install) {
+          integration.install();
+          log.success(`${integration.displayName} session hook installed`);
         }
       }
     }
@@ -745,7 +966,7 @@ function registerInit(program2) {
         log.info("Skipped \u2014 run later: workscribe config set ai.provider <provider>");
       }
     }
-    if (!import_fs6.default.existsSync(CONFIG_PATH)) {
+    if (!import_fs8.default.existsSync(CONFIG_PATH)) {
       writeConfig(config);
       log.success("Config file created");
     }
@@ -764,7 +985,7 @@ function registerInit(program2) {
 }
 
 // src/cli/status.ts
-var import_fs7 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 var import_chalk3 = __toESM(require("chalk"));
 
 // src/utils/format.ts
@@ -822,7 +1043,7 @@ function registerStatus(program2) {
     const total = getEventCount();
     const todayEvents = getEventsForDate(todayDate());
     const last = getLastEvent();
-    const isPaused = import_fs7.default.existsSync(PAUSE_FLAG_PATH);
+    const isPaused = import_fs9.default.existsSync(PAUSE_FLAG_PATH);
     log.plain("");
     log.plain(import_chalk3.default.bold("  Workscribe Status"));
     log.plain("");
@@ -861,9 +1082,15 @@ var CATEGORY_COLORS = {
   git_other: import_chalk4.default.blue,
   code_merge: import_chalk4.default.green,
   code_stash: import_chalk4.default.blue,
-  ai_session: import_chalk4.default.magenta,
+  ai_session: import_chalk4.default.bold.magenta,
+  code_search: import_chalk4.default.dim.cyan,
+  code_read: import_chalk4.default.dim.white,
+  file_ops: import_chalk4.default.yellow,
   other: import_chalk4.default.gray
 };
+var AI_TOOL_DISPLAY_NAMES = Object.fromEntries(
+  ai_tools_default.map((t) => [t.tool, t.displayName])
+);
 function registerEvents(program2) {
   program2.command("events").description("List captured events").option("--date <YYYY-MM-DD>", "date to list events for (default: today)").option("--limit <n>", "max events to show", parseInt).action((opts) => {
     let date = todayDate();
@@ -888,10 +1115,22 @@ function registerEvents(program2) {
       const colorFn = CATEGORY_COLORS[event.category] ?? import_chalk4.default.gray;
       const time = formatDate(event.captured_at);
       const category = colorFn(event.category.padEnd(20));
-      const cmd = import_chalk4.default.dim(event.command.slice(0, 55));
       const repo = event.repo_name ? import_chalk4.default.dim(` [${event.repo_name}]`) : "";
       const exitBadge = event.exit_code && event.exit_code !== 0 ? import_chalk4.default.red(` \u2717${event.exit_code}`) : "";
-      log.plain(`  ${import_chalk4.default.dim(time)}  ${category}  ${cmd}${repo}${exitBadge}`);
+      let cmdDisplay;
+      if (event.category === "ai_session") {
+        let meta = {};
+        try {
+          meta = event.metadata ? JSON.parse(event.metadata) : {};
+        } catch {
+        }
+        const toolKey = typeof meta.tool === "string" ? meta.tool : "";
+        const toolName = AI_TOOL_DISPLAY_NAMES[toolKey] ?? toolKey;
+        cmdDisplay = import_chalk4.default.white(toolName.padEnd(20)) + import_chalk4.default.magenta(" \u2726");
+      } else {
+        cmdDisplay = import_chalk4.default.dim(event.command.slice(0, 55));
+      }
+      log.plain(`  ${import_chalk4.default.dim(time)}  ${category}  ${cmdDisplay}${repo}${exitBadge}`);
     }
     if (limit < events.length) {
       log.plain("");
@@ -1033,8 +1272,8 @@ function registerSessions(program2) {
 
 // src/cli/summary.ts
 var import_chalk6 = __toESM(require("chalk"));
-var import_fs8 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
+var import_fs10 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
 
 // src/ai/prompt.ts
 var SYSTEM_PROMPT = `You write short developer work summaries. Here is an example:
@@ -1042,23 +1281,27 @@ var SYSTEM_PROMPT = `You write short developer work summaries. Here is an exampl
 INPUT:
 Project: api-service
 Branch: feature/auth
-Duration: 1h 30m
+Duration: 2h 00m
 Events:
   - branch_switch {"branch":"feature/auth"}
   - 2x dependency_install {"tool":"npm","packages":["bcrypt","jsonwebtoken"]}
   - 2x test_run {"tool":"jest"} [failed]
   - test_run {"tool":"jest"}
+  - 2x file_ops {"tool":"mkdir"}
   - code_commit {"message":"fix: auth token validation"}
+  - code_push {"remote":"origin","branch":"feature/auth"}
 
 OUTPUT:
-- Switched to the authentication feature branch
-- Added JWT and bcrypt dependencies
+- Switched to the authentication feature branch and installed JWT and bcrypt dependencies
 - Resolved failing auth tests
-- Committed authentication fixes
+- Committed and pushed authentication fixes
 
-For ai_session events: describe what was built during the AI session using the tool name (e.g. "via Claude Code"). If commits followed the session, group them into the same bullet. Maximum 5 bullets.
+Events like code_push, build, file_ops, and code_stash provide context \u2014 fold them into the surrounding narrative rather than listing them as separate bullets. Only surface them directly when they are the main activity (e.g. a standalone build fix, or a significant restructure with no accompanying commits).
 
-Now summarise the following. Output ONLY the bullet points, nothing else. Maximum 5 bullets.`;
+For ai_session events: describe what was built during the AI session using the tool name (e.g. "via Claude Code"). If a commits array is present in metadata, use those commit messages to describe what was built. Group all activity from the session into one narrative bullet.
+
+Maximum 5 bullets. Output ONLY the bullet points, nothing else.`;
+var EXCLUDED = /* @__PURE__ */ new Set(["environment", "code_search", "code_read", "server_run", "git_other"]);
 function buildUserMessage(payload) {
   const lines = [`Date: ${payload.date}`, ""];
   for (const session of payload.sessions) {
@@ -1068,6 +1311,7 @@ function buildUserMessage(payload) {
     lines.push("Events:");
     const counts = /* @__PURE__ */ new Map();
     for (const event of session.events) {
+      if (EXCLUDED.has(event.category)) continue;
       const meta = Object.keys(event.metadata).length > 0 ? ` ${JSON.stringify(event.metadata)}` : "";
       const failed = event.exitCode !== null && event.exitCode !== 0 ? " [failed]" : "";
       const key = `${event.category}${meta}${failed}`;
@@ -1124,6 +1368,7 @@ function buildWeeklyMessage(payload) {
       lines.push(`  Project: ${project}${branch} \u2014 ${formatDuration(s.durationMinutes)}`);
       const counts = /* @__PURE__ */ new Map();
       for (const e of s.events) {
+        if (EXCLUDED.has(e.category)) continue;
         const meta = Object.keys(e.metadata).length > 0 ? ` ${JSON.stringify(e.metadata)}` : "";
         const failed = e.exitCode !== null && e.exitCode !== 0 ? " [failed]" : "";
         const key = `${e.category}${meta}${failed}`;
@@ -1441,9 +1686,9 @@ function registerSummary(program2) {
         return;
       }
       const cacheKey = isoWeekKey(today);
-      const cacheFile = import_path4.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
-      if (!opts.fresh && import_fs8.default.existsSync(cacheFile)) {
-        const cached = import_fs8.default.readFileSync(cacheFile, "utf-8");
+      const cacheFile = import_path6.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
+      if (!opts.fresh && import_fs10.default.existsSync(cacheFile)) {
+        const cached = import_fs10.default.readFileSync(cacheFile, "utf-8");
         log.plain("");
         log.plain(cached);
         log.plain("");
@@ -1459,8 +1704,8 @@ function registerSummary(program2) {
         log.plain("");
         log.plain(summary);
         log.plain("");
-        import_fs8.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
-        import_fs8.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
+        import_fs10.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+        import_fs10.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
         await handleWebhook(opts, config, summary);
       } catch (e) {
         log.error(`Weekly summary failed [${config.ai.provider}]: ${e.message}`);
@@ -1523,8 +1768,8 @@ ${bullets.trim()}`;
 }
 
 // src/cli/export.ts
-var import_fs9 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
+var import_fs11 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
 function eventRowToPayload2(row) {
   let metadata = {};
   try {
@@ -1569,9 +1814,9 @@ function registerExport(program2) {
     const payload = { date, sessions: sessionPayloads };
     log.info(`Generating summary via ${config.ai.provider}\u2026`);
     const summary = await provider.summarize(payload);
-    const outputPath = opts.output ?? import_path5.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
-    if (!import_fs9.default.existsSync(EXPORTS_DIR)) import_fs9.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
-    import_fs9.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
+    const outputPath = opts.output ?? import_path7.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
+    if (!import_fs11.default.existsSync(EXPORTS_DIR)) import_fs11.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
+    import_fs11.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
 
 ${summary}
 `, { encoding: "utf-8", mode: 384 });
@@ -1629,22 +1874,22 @@ function printConfig(obj, indent) {
 }
 
 // src/cli/pause.ts
-var import_fs10 = __toESM(require("fs"));
+var import_fs12 = __toESM(require("fs"));
 function registerPause(program2) {
   program2.command("pause").description("Pause capture temporarily").action(() => {
-    if (import_fs10.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (import_fs12.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is already paused. Run workscribe resume to restart.");
       return;
     }
-    import_fs10.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
+    import_fs12.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
     log.success("Capture paused. Run workscribe resume to restart.");
   });
   program2.command("resume").description("Resume capture after a pause").action(() => {
-    if (!import_fs10.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (!import_fs12.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is not paused.");
       return;
     }
-    import_fs10.default.rmSync(PAUSE_FLAG_PATH);
+    import_fs12.default.rmSync(PAUSE_FLAG_PATH);
     log.success("Capture resumed.");
   });
 }
@@ -1678,10 +1923,61 @@ function registerUndo(program2) {
   });
 }
 
+// src/cli/clear.ts
+var import_chalk8 = __toESM(require("chalk"));
+var import_prompts2 = __toESM(require("prompts"));
+function registerClear(program2) {
+  program2.command("clear").description("Delete all captured events for a date").option("--date <YYYY-MM-DD>", "date to clear (default: today)").option("--dry-run", "preview what would be deleted without deleting").option("--yes", "skip confirmation prompt").action(async (opts) => {
+    let date = todayDate();
+    if (opts.date) {
+      try {
+        date = parseDate(opts.date);
+      } catch (e) {
+        log.error(e.message);
+        process.exit(1);
+      }
+    }
+    const events = getEventsForDate(date);
+    if (events.length === 0) {
+      log.plain(`No events found for ${date}.`);
+      return;
+    }
+    log.plain("");
+    log.plain(import_chalk8.default.bold(`  Events for ${date}  (${events.length} total)`));
+    log.plain("");
+    const counts = /* @__PURE__ */ new Map();
+    for (const e of events) counts.set(e.category, (counts.get(e.category) ?? 0) + 1);
+    for (const [cat, n] of counts) {
+      log.plain(`  ${import_chalk8.default.dim(String(n).padStart(4))}  ${cat}`);
+    }
+    log.plain("");
+    if (opts.dryRun) {
+      log.plain(import_chalk8.default.dim("  Dry run \u2014 nothing deleted."));
+      log.plain("");
+      return;
+    }
+    if (!opts.yes) {
+      const { confirm } = await (0, import_prompts2.default)({
+        type: "confirm",
+        name: "confirm",
+        message: `Delete all ${events.length} events for ${date}?`,
+        initial: false
+      });
+      if (!confirm) {
+        log.plain("Cancelled.");
+        return;
+      }
+    }
+    const deleted = deleteEventsForDate(date);
+    log.success(`Cleared ${deleted} event${deleted !== 1 ? "s" : ""} for ${date}.`);
+  });
+}
+
 // src/index.ts
 var program = new import_commander.Command();
-program.name("workscribe").description("Automatic developer work journal").version("1.3.0");
+program.name("workscribe").description("Automatic developer work journal").version("1.5.0");
 registerCapture(program);
+registerHook(program);
 registerInit(program);
 registerStatus(program);
 registerEvents(program);
@@ -1691,5 +1987,6 @@ registerExport(program);
 registerConfig(program);
 registerPause(program);
 registerUndo(program);
+registerClear(program);
 program.parse();
 //# sourceMappingURL=index.js.map