@workscribe/cli 1.7.2 → 1.8.0

package/README.md

@@ -148,6 +148,8 @@ workscribe summary --webhook https://custom.endpoint/hook                 # one-
 | `ai.baseUrl` | — | Base URL for `openai-compatible` providers |
 | `session.idleTimeout` | `30` | Minutes of inactivity before a new session starts |
 | `capture.ignore` | common shell builtins | Commands to exclude from capture |
+| `capture.aiTools` | `true` | Set to `false` to disable all AI session capture |
+| `capture.includeAiderPrompt` | `true` | Set to `false` to skip reading Aider's history file for prompt context |
 | `redact.extra` | `[]` | Additional regex patterns to redact from captured commands |
 | `summary.format` | `markdown` | Output format: `markdown` or `json` |
 | `integrations.slackWebhook` | — | Slack incoming webhook URL |

package/dist/index.js

@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 
 // src/capture/index.ts
-var import_fs4 = __toESM(require("fs"));
+var import_fs7 = __toESM(require("fs"));
 
 // src/db/index.ts
 var import_node_sqlite = require("node:sqlite");
@@ -345,6 +345,28 @@ function getCommitsSince(sha, cwd) {
   }
 }
 
+// src/capture/aider.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var HISTORY_FILE = ".aider.chat.history.md";
+var PROMPT_MAX_LENGTH = 200;
+function readLastAiderPrompt(cwd) {
+  try {
+    const histPath = import_path3.default.join(cwd, HISTORY_FILE);
+    const content = import_fs3.default.readFileSync(histPath, "utf-8");
+    const matches = [...content.matchAll(/^> (.+)$/gm)];
+    if (!matches.length) return null;
+    return matches[matches.length - 1][1].trim().slice(0, PROMPT_MAX_LENGTH);
+  } catch {
+    return null;
+  }
+}
+
+// src/config/registry.ts
+var import_fs5 = __toESM(require("fs"));
+var import_os2 = __toESM(require("os"));
+var import_path4 = __toESM(require("path"));
+
 // src/config/ai-tools.json
 var ai_tools_default = [
   {
@@ -405,6 +427,54 @@ var ai_tools_default = [
   }
 ];
 
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var import_fs4 = __toESM(require("fs"));
+var isDebug = process.env.WORKSCRIBE_DEBUG === "1";
+var log = {
+  info: (msg) => console.log(import_chalk.default.cyan("\u2192"), msg),
+  success: (msg) => console.log(import_chalk.default.green("\u2713"), msg),
+  warn: (msg) => console.log(import_chalk.default.yellow("\u26A0"), msg),
+  error: (msg) => console.error(import_chalk.default.red("\u2717"), msg),
+  plain: (msg) => console.log(msg)
+};
+function debugLog(context, error) {
+  if (!isDebug) return;
+  const entry = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${context}] ${error instanceof Error ? error.stack : String(error)}
+`;
+  try {
+    import_fs4.default.appendFileSync(DEBUG_LOG_PATH, entry, { mode: 384 });
+  } catch {
+  }
+}
+
+// src/config/registry.ts
+var USER_REGISTRY_PATH = import_path4.default.join(import_os2.default.homedir(), ".workscribe", "ai-tools.json");
+function loadAIToolRegistry() {
+  let userEntries = [];
+  try {
+    if (import_fs5.default.existsSync(USER_REGISTRY_PATH)) {
+      const raw = import_fs5.default.readFileSync(USER_REGISTRY_PATH, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        userEntries = parsed.filter((entry) => typeof entry.tool === "string" && typeof entry.pattern === "string").map((entry) => ({
+          tool: entry.tool,
+          displayName: entry.displayName ?? entry.tool,
+          pattern: entry.pattern,
+          hook: entry.hook ?? null,
+          contextSource: entry.contextSource ?? null
+        }));
+      }
+    }
+  } catch {
+    debugLog("registry", "Failed to load user AI tool registry \u2014 using built-ins only");
+  }
+  if (userEntries.length === 0) return ai_tools_default;
+  const userToolSlugs = new Set(userEntries.map((entry) => entry.tool));
+  const filteredBuiltins = ai_tools_default.filter((entry) => !userToolSlugs.has(entry.tool));
+  return [...filteredBuiltins, ...userEntries];
+}
+
 // src/normalize/patterns.ts
 function makeRule(pattern, category, extract = () => ({})) {
   return {
@@ -596,7 +666,14 @@ var RULES = [
   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 })))
+  ...loadAIToolRegistry().flatMap((entry) => {
+    try {
+      return [makeRule(new RegExp(entry.pattern), "ai_session", () => ({ tool: entry.tool }))];
+    } catch {
+      debugLog("registry", `Skipping tool "${entry.tool}" \u2014 invalid pattern: ${entry.pattern}`);
+      return [];
+    }
+  })
 ];
 function normalizeCommand(command) {
   let trimmed = command.trim().replace(/\s+/g, " ");
@@ -609,7 +686,7 @@ function normalizeCommand(command) {
 }
 
 // src/config/index.ts
-var import_fs3 = __toESM(require("fs"));
+var import_fs6 = __toESM(require("fs"));
 var DEFAULTS = {
   ai: {
     provider: "",
@@ -621,7 +698,9 @@ var DEFAULTS = {
     idleTimeout: 30
   },
   capture: {
-    ignore: ["cd", "ls", "ll", "la", "ls -la", "ls -l", "ls -a", "pwd", "clear", "exit", "history", "man"]
+    ignore: ["cd", "ls", "ll", "la", "ls -la", "ls -l", "ls -a", "pwd", "clear", "exit", "history", "man"],
+    aiTools: true,
+    includeAiderPrompt: true
   },
   redact: {
     extra: []
@@ -631,9 +710,9 @@ var DEFAULTS = {
   }
 };
 function readConfig() {
-  if (!import_fs3.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
+  if (!import_fs6.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
   try {
-    const raw = import_fs3.default.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = import_fs6.default.readFileSync(CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     return deepMerge(DEFAULTS, parsed);
   } catch {
@@ -641,9 +720,9 @@ function readConfig() {
   }
 }
 function writeConfig(config) {
-  import_fs3.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  import_fs6.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
   try {
-    import_fs3.default.chmodSync(CONFIG_PATH, 384);
+    import_fs6.default.chmodSync(CONFIG_PATH, 384);
   } catch {
   }
 }
@@ -710,7 +789,7 @@ function isDuplicate(command, cwd, lastEvent, dedupWindowMs = 5e3, now = Date.no
 
 // src/capture/index.ts
 function captureCommand(opts) {
-  if (import_fs4.default.existsSync(PAUSE_FLAG_PATH)) return;
+  if (import_fs7.default.existsSync(PAUSE_FLAG_PATH)) return;
   const config = readConfig();
   const { command, cwd, exitCode, durationMs } = opts;
   if (shouldFilter(command, config.capture.ignore)) return;
@@ -720,10 +799,20 @@ function captureCommand(opts) {
   const nameOverride = config.projects?.[cwd] ?? null;
   const { repoName, branch } = getGitContext(cwd, nameOverride);
   const { category, metadata } = normalizeCommand(safeCommand);
+  if (category === "ai_session" && config.capture.aiTools === false) return;
   if (opts.source) metadata.source = opts.source;
-  if (category === "ai_session" && opts.gitBefore) {
-    const commits = getCommitsSince(opts.gitBefore, cwd);
-    if (commits.length > 0) metadata.commits = commits;
+  if (category === "ai_session") {
+    if (opts.gitBefore) {
+      const commits = getCommitsSince(opts.gitBefore, cwd);
+      if (commits.length > 0) metadata.commits = commits;
+    }
+    if (config.capture.includeAiderPrompt !== false) {
+      const toolEntry = loadAIToolRegistry().find((entry) => entry.tool === metadata.tool);
+      if (toolEntry?.contextSource === "history-file") {
+        const prompt = readLastAiderPrompt(cwd);
+        if (prompt) metadata.prompt = prompt;
+      }
+    }
   }
   insertEvent({
     captured_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -738,27 +827,6 @@ function captureCommand(opts) {
   });
 }
 
-// src/utils/logger.ts
-var import_chalk = __toESM(require("chalk"));
-var import_fs5 = __toESM(require("fs"));
-var isDebug = process.env.WORKSCRIBE_DEBUG === "1";
-var log = {
-  info: (msg) => console.log(import_chalk.default.cyan("\u2192"), msg),
-  success: (msg) => console.log(import_chalk.default.green("\u2713"), msg),
-  warn: (msg) => console.log(import_chalk.default.yellow("\u26A0"), msg),
-  error: (msg) => console.error(import_chalk.default.red("\u2717"), msg),
-  plain: (msg) => console.log(msg)
-};
-function debugLog(context, error) {
-  if (!isDebug) return;
-  const entry = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${context}] ${error instanceof Error ? error.stack : String(error)}
-`;
-  try {
-    import_fs5.default.appendFileSync(DEBUG_LOG_PATH, entry, { mode: 384 });
-  } catch {
-  }
-}
-
 // 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).option("--git-before <sha>", "git HEAD SHA before this command ran").action((opts) => {
@@ -796,6 +864,7 @@ function registerHook(program2) {
     });
     process.stdin.on("end", () => {
       try {
+        if (readConfig().capture.aiTools === false) return;
         const parsed = parseHookPayload(raw);
         if (!parsed) return;
         captureCommand({
@@ -813,21 +882,21 @@ function registerHook(program2) {
 }
 
 // src/cli/init.ts
-var import_fs8 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
+var import_fs10 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_os4 = __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 import_fs8 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
 var HOOK_START = "# workscribe:hook:start";
 var HOOK_END = "# workscribe:hook:end";
 var HOOK_PREAMBLE = "# Workscribe \u2014 developer work journal";
 function getInstalledHookBlock(rcFile) {
-  if (!import_fs6.default.existsSync(rcFile)) return null;
-  const content = import_fs6.default.readFileSync(rcFile, "utf-8");
+  if (!import_fs8.default.existsSync(rcFile)) return null;
+  const content = import_fs8.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -843,39 +912,39 @@ function isHookOutdated(rcFile, hookContent) {
 }
 function installHook(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)}`);
-  import_fs6.default.appendFileSync(rcFile, `
+  import_fs8.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
+  import_fs8.default.appendFileSync(rcFile, `
 ${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");
+  import_fs8.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
+  const content = import_fs8.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));
+  import_fs8.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
 }
 function removeHook(rcFile) {
   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");
+  import_fs8.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
+  const content = import_fs8.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
   const preambleIdx = content.lastIndexOf(HOOK_PREAMBLE, startIdx);
   const blockStart = preambleIdx !== -1 ? preambleIdx : startIdx;
   const before = content.slice(0, blockStart).replace(/\n+$/, "\n");
   const after = content.slice(endIdx).replace(/^\n/, "");
-  import_fs6.default.writeFileSync(rcFile, before + after);
+  import_fs8.default.writeFileSync(rcFile, before + after);
 }
 
 // src/capture/hooks/claude-code.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
-var import_os2 = __toESM(require("os"));
+var import_fs9 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
 
 // src/capture/hooks/utils.ts
 var import_child_process3 = require("child_process");
@@ -889,11 +958,11 @@ function isCommandInstalled(cmd) {
 }
 
 // src/capture/hooks/claude-code.ts
-var CLAUDE_SETTINGS_PATH = import_path4.default.join(import_os2.default.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = import_path6.default.join(import_os3.default.homedir(), ".claude", "settings.json");
 function readSettings() {
-  if (!import_fs7.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  if (!import_fs9.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(import_fs7.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+    return JSON.parse(import_fs9.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -928,8 +997,8 @@ var claudeCodeIntegration = {
         }
       ]
     };
-    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));
+    import_fs9.default.mkdirSync(import_path6.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+    import_fs9.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
   }
 };
 
@@ -941,19 +1010,19 @@ var AI_HOOK_INTEGRATIONS = {
 // 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") };
+  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path7.default.join(import_os4.default.homedir(), ".zshrc") };
+  if (shell.includes("bash")) return { name: "bash", rcFile: import_path7.default.join(import_os4.default.homedir(), ".bashrc") };
   return null;
 }
 function registerInit(program2) {
   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_fs8.default.existsSync(WORKSCRIBE_DIR)) {
-      import_fs8.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
+    if (!import_fs10.default.existsSync(WORKSCRIBE_DIR)) {
+      import_fs10.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
       log.success(`Created ${WORKSCRIBE_DIR}`);
     } else {
       try {
-        import_fs8.default.chmodSync(WORKSCRIBE_DIR, 448);
+        import_fs10.default.chmodSync(WORKSCRIBE_DIR, 448);
       } catch {
       }
     }
@@ -964,12 +1033,12 @@ 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 {
-      const hookFile = import_path5.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
-      if (!import_fs8.default.existsSync(hookFile)) {
+      const hookFile = import_path7.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
+      if (!import_fs10.default.existsSync(hookFile)) {
         log.warn(`Hook template not found at ${hookFile}`);
       } else {
-        const hookContent = import_fs8.default.readFileSync(hookFile, "utf-8");
-        if (!import_fs8.default.existsSync(shell.rcFile)) import_fs8.default.writeFileSync(shell.rcFile, "");
+        const hookContent = import_fs10.default.readFileSync(hookFile, "utf-8");
+        if (!import_fs10.default.existsSync(shell.rcFile)) import_fs10.default.writeFileSync(shell.rcFile, "");
         if (!isHookInstalled(shell.rcFile)) {
           installHook(shell.rcFile, hookContent);
           log.success(`Shell hook installed in ${shell.rcFile}`);
@@ -991,21 +1060,29 @@ function registerInit(program2) {
         }
       }
     }
-    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`);
+    const installedTools = loadAIToolRegistry().filter(
+      (t) => t.hook !== null && AI_HOOK_INTEGRATIONS[t.hook]?.isInstalled()
+    );
+    if (installedTools.length === 0) {
+      log.info("No AI coding tools detected \u2014 re-run workscribe init after installing one");
+    } else {
+      for (const tool of installedTools) {
+        const integration = AI_HOOK_INTEGRATIONS[tool.hook];
+        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: false
+          });
+          if (install) {
+            integration.install();
+            log.success(`${integration.displayName} session hook installed`);
+          } else {
+            log.info(`${integration.displayName} hook skipped \u2014 re-run workscribe init to install later`);
+          }
         }
       }
     }
@@ -1057,7 +1134,7 @@ function registerInit(program2) {
         log.info("Skipped \u2014 run later: workscribe config set ai.provider <provider>");
       }
     }
-    if (!import_fs8.default.existsSync(CONFIG_PATH)) {
+    if (!import_fs10.default.existsSync(CONFIG_PATH)) {
       writeConfig(config);
       log.success("Config file created");
     }
@@ -1076,7 +1153,7 @@ function registerInit(program2) {
 }
 
 // src/cli/status.ts
-var import_fs9 = __toESM(require("fs"));
+var import_fs11 = __toESM(require("fs"));
 var import_chalk3 = __toESM(require("chalk"));
 
 // src/utils/format.ts
@@ -1134,7 +1211,7 @@ function registerStatus(program2) {
     const total = getEventCount();
     const todayEvents = getEventsForDate(todayDate());
     const last = getLastEvent();
-    const isPaused = import_fs9.default.existsSync(PAUSE_FLAG_PATH);
+    const isPaused = import_fs11.default.existsSync(PAUSE_FLAG_PATH);
     log.plain("");
     log.plain(import_chalk3.default.bold("  Workscribe Status"));
     log.plain("");
@@ -1182,7 +1259,9 @@ var CATEGORY_COLORS = {
   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]));
+var AI_TOOL_DISPLAY_NAMES = Object.fromEntries(
+  loadAIToolRegistry().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();
@@ -1370,9 +1449,9 @@ function registerSessions(program2) {
 
 // src/cli/summary.ts
 var import_chalk6 = __toESM(require("chalk"));
-var import_fs10 = __toESM(require("fs"));
-var import_os4 = __toESM(require("os"));
-var import_path6 = __toESM(require("path"));
+var import_fs12 = __toESM(require("fs"));
+var import_os5 = __toESM(require("os"));
+var import_path8 = __toESM(require("path"));
 
 // src/ai/prompt.ts
 var SYSTEM_PROMPT = `You write short developer work summaries. Here is an example:
@@ -1767,7 +1846,7 @@ async function handleWebhook(opts, config, summary) {
   if (webhookUrl) {
     try {
       log.info("Posting to webhook\u2026");
-      const username = import_os4.default.userInfo().username;
+      const username = import_os5.default.userInfo().username;
       const body = isSlackWebhookUrl(webhookUrl) ? formatForSlack(summary, username) : summary;
       await postToWebhook(webhookUrl, body);
       log.success("Posted.");
@@ -1804,9 +1883,9 @@ function registerSummary(program2) {
         return;
       }
       const cacheKey = isoWeekKey(today);
-      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");
+      const cacheFile = import_path8.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
+      if (!opts.fresh && import_fs12.default.existsSync(cacheFile)) {
+        const cached = import_fs12.default.readFileSync(cacheFile, "utf-8");
         log.plain("");
         log.plain(cached);
         log.plain("");
@@ -1822,8 +1901,8 @@ function registerSummary(program2) {
         log.plain("");
         log.plain(summary);
         log.plain("");
-        import_fs10.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
-        import_fs10.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
+        import_fs12.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+        import_fs12.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}`);
@@ -1910,8 +1989,8 @@ ${bullets.trim()}`;
 }
 
 // src/cli/export.ts
-var import_fs11 = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
+var import_fs13 = __toESM(require("fs"));
+var import_path9 = __toESM(require("path"));
 function eventRowToPayload2(row) {
   let metadata = {};
   try {
@@ -1956,9 +2035,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_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}
+    const outputPath = opts.output ?? import_path9.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
+    if (!import_fs13.default.existsSync(EXPORTS_DIR)) import_fs13.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
+    import_fs13.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
 
 ${summary}
 `, { encoding: "utf-8", mode: 384 });
@@ -2030,22 +2109,22 @@ function printConfig(obj, indent) {
 }
 
 // src/cli/pause.ts
-var import_fs12 = __toESM(require("fs"));
+var import_fs14 = __toESM(require("fs"));
 function registerPause(program2) {
   program2.command("pause").description("Pause capture temporarily").action(() => {
-    if (import_fs12.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (import_fs14.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is already paused. Run workscribe resume to restart.");
       return;
     }
-    import_fs12.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
+    import_fs14.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_fs12.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (!import_fs14.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is not paused.");
       return;
     }
-    import_fs12.default.rmSync(PAUSE_FLAG_PATH);
+    import_fs14.default.rmSync(PAUSE_FLAG_PATH);
     log.success("Capture resumed.");
   });
 }
@@ -2130,18 +2209,18 @@ function registerClear(program2) {
 }
 
 // src/cli/uninstall.ts
-var import_fs13 = __toESM(require("fs"));
-var import_path8 = __toESM(require("path"));
-var import_os5 = __toESM(require("os"));
+var import_fs15 = __toESM(require("fs"));
+var import_path10 = __toESM(require("path"));
+var import_os6 = __toESM(require("os"));
 var import_prompts3 = __toESM(require("prompts"));
 var import_chalk9 = __toESM(require("chalk"));
 function detectShellRcFiles() {
   const candidates = [
-    { name: "zsh", rcFile: import_path8.default.join(import_os5.default.homedir(), ".zshrc") },
-    { name: "bash", rcFile: import_path8.default.join(import_os5.default.homedir(), ".bashrc") },
-    { name: "bash", rcFile: import_path8.default.join(import_os5.default.homedir(), ".bash_profile") }
+    { name: "zsh", rcFile: import_path10.default.join(import_os6.default.homedir(), ".zshrc") },
+    { name: "bash", rcFile: import_path10.default.join(import_os6.default.homedir(), ".bashrc") },
+    { name: "bash", rcFile: import_path10.default.join(import_os6.default.homedir(), ".bash_profile") }
   ];
-  return candidates.filter((c) => import_fs13.default.existsSync(c.rcFile) && isHookInstalled(c.rcFile));
+  return candidates.filter((c) => import_fs15.default.existsSync(c.rcFile) && isHookInstalled(c.rcFile));
 }
 function registerUninstall(program2) {
   program2.command("uninstall").description("Remove shell hooks and optionally delete all Workscribe data").option("--hooks-only", "remove shell hooks only, skip data deletion prompt (used by npm preuninstall)").action(async (opts) => {
@@ -2160,7 +2239,7 @@ function registerUninstall(program2) {
       }
     }
     if (opts.hooksOnly) return;
-    if (import_fs13.default.existsSync(WORKSCRIBE_DIR)) {
+    if (import_fs15.default.existsSync(WORKSCRIBE_DIR)) {
       log.plain("");
       const { deleteData } = await (0, import_prompts3.default)({
         type: "confirm",
@@ -2169,7 +2248,7 @@ function registerUninstall(program2) {
         initial: false
       });
       if (deleteData) {
-        import_fs13.default.rmSync(WORKSCRIBE_DIR, { recursive: true, force: true });
+        import_fs15.default.rmSync(WORKSCRIBE_DIR, { recursive: true, force: true });
         log.success(`Deleted ${WORKSCRIBE_DIR}`);
       } else {
         log.info(`Data kept at ${WORKSCRIBE_DIR}`);
@@ -2183,7 +2262,7 @@ function registerUninstall(program2) {
 
 // src/index.ts
 var program = new import_commander.Command();
-program.name("workscribe").description("Automatic developer work journal").version("1.7.2");
+program.name("workscribe").description("Automatic developer work journal").version("1.8.0");
 registerCapture(program);
 registerHook(program);
 registerInit(program);