@workscribe/cli 0.2.1

package/dist/index.js

@@ -0,0 +1,1234 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/db/index.ts
+var import_node_sqlite = require("node:sqlite");
+var import_fs = __toESM(require("fs"));
+
+// src/utils/paths.ts
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var CHRONICLE_DIR = import_path.default.join(import_os.default.homedir(), ".chronicle");
+var DB_PATH = import_path.default.join(CHRONICLE_DIR, "chronicle.db");
+var CONFIG_PATH = import_path.default.join(CHRONICLE_DIR, "config.json");
+var DEBUG_LOG_PATH = import_path.default.join(CHRONICLE_DIR, "debug.log");
+var EXPORTS_DIR = import_path.default.join(CHRONICLE_DIR, "exports");
+
+// src/db/index.ts
+var _db = null;
+function getDb() {
+  if (_db) return _db;
+  if (!import_fs.default.existsSync(CHRONICLE_DIR)) {
+    import_fs.default.mkdirSync(CHRONICLE_DIR, { recursive: true });
+  }
+  _db = new import_node_sqlite.DatabaseSync(DB_PATH);
+  _db.exec("PRAGMA journal_mode = WAL");
+  _db.exec("PRAGMA foreign_keys = ON");
+  runMigrations(_db);
+  return _db;
+}
+function runMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      captured_at TEXT    NOT NULL,
+      command     TEXT    NOT NULL,
+      cwd         TEXT    NOT NULL,
+      exit_code   INTEGER,
+      duration_ms INTEGER,
+      repo_name   TEXT,
+      branch      TEXT,
+      category    TEXT    NOT NULL DEFAULT 'other',
+      metadata    TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_events_captured_at ON events(captured_at);
+    CREATE INDEX IF NOT EXISTS idx_events_repo_name   ON events(repo_name);
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      date        TEXT    NOT NULL,
+      started_at  TEXT    NOT NULL,
+      ended_at    TEXT    NOT NULL,
+      repo_name   TEXT,
+      event_count INTEGER NOT NULL DEFAULT 0,
+      summary     TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_date ON sessions(date);
+
+    CREATE TABLE IF NOT EXISTS session_events (
+      session_id  INTEGER NOT NULL REFERENCES sessions(id),
+      event_id    INTEGER NOT NULL REFERENCES events(id),
+      PRIMARY KEY (session_id, event_id)
+    );
+  `);
+}
+function insertEvent(params) {
+  const db = getDb();
+  const stmt = db.prepare(`
+    INSERT INTO events (captured_at, command, cwd, exit_code, duration_ms, repo_name, branch, category, metadata)
+    VALUES ($captured_at, $command, $cwd, $exit_code, $duration_ms, $repo_name, $branch, $category, $metadata)
+  `);
+  stmt.run(params);
+}
+function getLastEvent() {
+  const db = getDb();
+  const stmt = db.prepare("SELECT * FROM events ORDER BY id DESC LIMIT 1");
+  return stmt.get();
+}
+function getEventsForDate(date) {
+  const db = getDb();
+  const stmt = db.prepare(`
+    SELECT * FROM events
+    WHERE date(captured_at) = $date
+    ORDER BY captured_at ASC
+  `);
+  return stmt.all({ date });
+}
+function getEventCount() {
+  const db = getDb();
+  const stmt = db.prepare("SELECT COUNT(*) as count FROM events");
+  const row = stmt.get();
+  return row.count;
+}
+function insertSession(params) {
+  const db = getDb();
+  const stmt = db.prepare(`
+    INSERT INTO sessions (date, started_at, ended_at, repo_name, event_count, summary)
+    VALUES ($date, $started_at, $ended_at, $repo_name, $event_count, $summary)
+  `);
+  const result = stmt.run(params);
+  return Number(result.lastInsertRowid);
+}
+function insertSessionEvent(sessionId, eventId) {
+  const db = getDb();
+  const stmt = db.prepare(`
+    INSERT OR IGNORE INTO session_events (session_id, event_id) VALUES ($session_id, $event_id)
+  `);
+  stmt.run({ session_id: sessionId, event_id: eventId });
+}
+function getSessionsForDate(date) {
+  const db = getDb();
+  const stmt = db.prepare("SELECT * FROM sessions WHERE date = $date ORDER BY started_at ASC");
+  return stmt.all({ date });
+}
+function updateSessionSummary(sessionId, summary) {
+  const db = getDb();
+  const stmt = db.prepare("UPDATE sessions SET summary = $summary WHERE id = $id");
+  stmt.run({ summary, id: sessionId });
+}
+function clearSessionsForDate(date) {
+  const db = getDb();
+  db.exec(`
+    DELETE FROM session_events WHERE session_id IN (
+      SELECT id FROM sessions WHERE date = '${date.replace(/'/g, "''")}'
+    )
+  `);
+  db.exec(`DELETE FROM sessions WHERE date = '${date.replace(/'/g, "''")}'`);
+}
+
+// src/capture/redact.ts
+var BUILTIN_PATTERNS = [
+  // AWS access keys
+  /AKIA[0-9A-Z]{16}/g,
+  // AWS secret access keys (40 char base64-ish after common env vars)
+  /(?<=AWS_SECRET_ACCESS_KEY[=\s]+)\S+/gi,
+  // GitHub tokens
+  /ghp_[a-zA-Z0-9]{36}/g,
+  /github_pat_[a-zA-Z0-9_]{82}/g,
+  // GitLab tokens
+  /glpat-[a-zA-Z0-9\-]{20}/g,
+  // Generic JWTs (three base64url segments)
+  /eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/g,
+  // Slack tokens
+  /xox[baprs]-[a-zA-Z0-9\-]+/g,
+  // Stripe keys
+  /sk_(live|test)_[a-zA-Z0-9]{24,}/g,
+  // Values after long-form secret flags (single-char flags like -t/-p/-k are too ambiguous)
+  /(?<=--(password|passwd|secret|token|key|api[-_]?key|auth[-_]?token)\s+)\S+/gi,
+  // export VAR=VALUE where VAR looks sensitive
+  /(?<=export\s+(?:[A-Z_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASS|AUTH|CREDENTIAL)[A-Z_]*)=)\S+/gi
+];
+function redact(command, extraPatterns = []) {
+  let result = command;
+  const allPatterns = [...BUILTIN_PATTERNS];
+  for (const pattern of extraPatterns) {
+    try {
+      allPatterns.push(new RegExp(pattern, "g"));
+    } catch {
+    }
+  }
+  for (const pattern of allPatterns) {
+    pattern.lastIndex = 0;
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  return result;
+}
+
+// src/capture/git.ts
+var import_child_process = require("child_process");
+var import_path2 = __toESM(require("path"));
+function getGitContext(cwd) {
+  try {
+    const root = (0, import_child_process.execSync)("git rev-parse --show-toplevel", {
+      cwd,
+      timeout: 2e3,
+      stdio: "pipe"
+    }).toString().trim();
+    const repoName = import_path2.default.basename(root);
+    let branch = null;
+    try {
+      branch = (0, import_child_process.execSync)("git branch --show-current", {
+        cwd,
+        timeout: 2e3,
+        stdio: "pipe"
+      }).toString().trim() || null;
+    } catch {
+    }
+    return { repoName, branch };
+  } catch {
+    return { repoName: null, branch: null };
+  }
+}
+
+// src/normalize/patterns.ts
+function makeRule(pattern, category, extract = () => ({})) {
+  return {
+    match(cmd) {
+      const m = cmd.match(pattern);
+      if (!m) return null;
+      return { category, metadata: extract(m, cmd) };
+    }
+  };
+}
+function extractPackages(cmd, afterKeyword) {
+  const idx = cmd.indexOf(afterKeyword);
+  if (idx === -1) return [];
+  return cmd.slice(idx + afterKeyword.length).trim().split(/\s+/).filter((p) => p && !p.startsWith("-"));
+}
+var RULES = [
+  // ─── Git operations ───────────────────────────────────────────────────────
+  makeRule(/^git\s+commit\b/, "code_commit", (_m, cmd) => {
+    const msgMatch = cmd.match(/-m\s+["']?([^"']+)["']?/);
+    return { message: msgMatch ? msgMatch[1].trim() : null };
+  }),
+  makeRule(/^git\s+push\b/, "code_push", (_m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { remote: parts[2] ?? "origin", branch: parts[3] ?? null };
+  }),
+  makeRule(/^git\s+(pull|fetch)\b/, "code_pull", (_m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { subcommand: parts[1], remote: parts[2] ?? "origin" };
+  }),
+  makeRule(/^git\s+(checkout|switch)\b/, "branch_switch", (_m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    const branch = parts.find((p) => !p.startsWith("-") && p !== "git" && p !== parts[1]);
+    return { branch: branch ?? null };
+  }),
+  makeRule(/^git\s+(merge|rebase)\b/, "code_merge", (_m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { subcommand: parts[1], target: parts[2] ?? null };
+  }),
+  makeRule(/^git\s+stash\b/, "code_stash", (_m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { subcommand: parts[2] ?? "push" };
+  }),
+  makeRule(/^git\s+/, "git_other", (_m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { subcommand: parts[1] ?? null };
+  }),
+  // ─── Package managers — install ───────────────────────────────────────────
+  makeRule(/^npm\s+(install|i|add)\b/, "dependency_install", (_m, cmd) => ({
+    tool: "npm",
+    packages: extractPackages(cmd, cmd.includes("install") ? "install" : cmd.includes(" i ") ? " i " : "add")
+  })),
+  makeRule(/^(yarn|pnpm)\s+(install|add)\b/, "dependency_install", (m, cmd) => ({
+    tool: m[1],
+    packages: extractPackages(cmd, "add")
+  })),
+  makeRule(/^pip\s+(install)\b/, "dependency_install", (_m, cmd) => ({
+    tool: "pip",
+    packages: extractPackages(cmd, "install")
+  })),
+  makeRule(/^cargo\s+add\b/, "dependency_install", (_m, cmd) => ({
+    tool: "cargo",
+    packages: extractPackages(cmd, "add")
+  })),
+  makeRule(/^(brew)\s+install\b/, "dependency_install", (_m, cmd) => ({
+    tool: "brew",
+    packages: extractPackages(cmd, "install")
+  })),
+  makeRule(/^go\s+get\b/, "dependency_install", (_m, cmd) => ({
+    tool: "go",
+    packages: extractPackages(cmd, "get")
+  })),
+  // ─── Package managers — remove ────────────────────────────────────────────
+  makeRule(/^npm\s+(uninstall|remove|rm)\b/, "dependency_remove", (_m, cmd) => ({
+    tool: "npm",
+    packages: extractPackages(cmd, cmd.split(/\s+/)[1])
+  })),
+  makeRule(/^(yarn|pnpm)\s+remove\b/, "dependency_remove", (m, cmd) => ({
+    tool: m[1],
+    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(/^(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" })),
+  makeRule(/^cargo\s+test\b/, "test_run", () => ({ tool: "cargo" })),
+  makeRule(/^rspec\b/, "test_run", () => ({ tool: "rspec" })),
+  makeRule(/^(php\s+)?phpunit\b/, "test_run", () => ({ tool: "phpunit" })),
+  // ─── Build ────────────────────────────────────────────────────────────────
+  makeRule(/^npm\s+run\s+build\b/, "build", () => ({ tool: "npm" })),
+  makeRule(/^(yarn|pnpm)\s+build\b/, "build", (m) => ({ tool: m[1] })),
+  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" })),
+  makeRule(/^docker\s+build\b/, "build", () => ({ tool: "docker" })),
+  makeRule(/^(mvn|gradle)\b/, "build", (m) => ({ tool: m[1] })),
+  // ─── Dev server ───────────────────────────────────────────────────────────
+  makeRule(/^npm\s+run\s+(dev|start|serve)\b/, "server_run", (_m, cmd) => ({
+    tool: "npm",
+    script: cmd.split(/\s+/)[2]
+  })),
+  makeRule(/^(yarn|pnpm)\s+(dev|start)\b/, "server_run", (m) => ({ tool: m[1], script: m[2] })),
+  makeRule(/^python\s+.*manage\.py\s+runserver\b/, "server_run", () => ({ tool: "django" })),
+  // ─── Infrastructure ───────────────────────────────────────────────────────
+  makeRule(/^ssh\b/, "infrastructure", (_m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { tool: "ssh", target: parts[parts.length - 1] };
+  }),
+  makeRule(/^kubectl\b/, "infrastructure", (_m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { tool: "kubectl", subcommand: parts[1] ?? null };
+  }),
+  makeRule(/^(helm|terraform|pulumi)\b/, "infrastructure", (m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { tool: m[1], subcommand: parts[1] ?? null };
+  }),
+  makeRule(/^docker\s+(run|compose|ps|stop|start|rm|exec)\b/, "infrastructure", (m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { tool: "docker", subcommand: parts[1] };
+  }),
+  makeRule(/^(aws|gcloud|az)\b/, "infrastructure", (m, cmd) => {
+    const parts = cmd.split(/\s+/);
+    return { tool: m[1], subcommand: parts[1] ?? null };
+  }),
+  // ─── Scripts ──────────────────────────────────────────────────────────────
+  makeRule(/^(bash|sh|zsh|fish)\s+\S+/, "script_run", (m) => ({ shell: m[1] })),
+  makeRule(/^node\s+\S+\.(?:js|mjs|cjs)\b/, "script_run", () => ({ runtime: "node" })),
+  makeRule(/^python3?\s+\S+\.py\b/, "script_run", () => ({ runtime: "python" })),
+  // ─── Environment ──────────────────────────────────────────────────────────
+  makeRule(/^export\s+\w+=/, "environment", (_m, cmd) => {
+    const varName = cmd.match(/^export\s+(\w+)=/)?.[1] ?? null;
+    return { variable: varName };
+  }),
+  makeRule(/^source\s+/, "environment", () => ({})),
+  // ─── npm scripts (generic) ────────────────────────────────────────────────
+  makeRule(/^npm\s+run\s+\S+/, "script_run", (_m, cmd) => ({
+    tool: "npm",
+    script: cmd.split(/\s+/)[2]
+  }))
+];
+function normalizeCommand(command) {
+  const trimmed = command.trim().replace(/\s+/g, " ");
+  for (const rule of RULES) {
+    const result = rule.match(trimmed);
+    if (result) return result;
+  }
+  return { category: "other", metadata: {} };
+}
+
+// src/config/index.ts
+var import_fs2 = __toESM(require("fs"));
+var DEFAULTS = {
+  ai: {
+    provider: "",
+    apiKey: "",
+    model: "",
+    baseUrl: ""
+  },
+  session: {
+    idleTimeout: 30
+  },
+  capture: {
+    ignore: ["cd", "ls", "ll", "la", "ls -la", "ls -l", "ls -a", "pwd", "clear", "exit", "history", "man"]
+  },
+  redact: {
+    extra: []
+  },
+  summary: {
+    format: "markdown"
+  }
+};
+function readConfig() {
+  if (!import_fs2.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
+  try {
+    const raw = import_fs2.default.readFileSync(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(DEFAULTS, parsed);
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+function writeConfig(config) {
+  import_fs2.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function getConfigValue(config, key) {
+  const parts = key.split(".");
+  let cur = config;
+  for (const part of parts) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function setConfigValue(config, key, value) {
+  const parts = key.split(".");
+  const result = JSON.parse(JSON.stringify(config));
+  let cur = result;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (cur[part] == null || typeof cur[part] !== "object") {
+      cur[part] = {};
+    }
+    cur = cur[part];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (value === "true") cur[lastKey] = true;
+  else if (value === "false") cur[lastKey] = false;
+  else if (!isNaN(Number(value))) cur[lastKey] = Number(value);
+  else cur[lastKey] = value;
+  return result;
+}
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const val = overrides[key];
+    if (val !== null && typeof val === "object" && !Array.isArray(val) && typeof defaults[key] === "object") {
+      result[key] = deepMerge(defaults[key], val);
+    } else if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+// src/capture/filter.ts
+function normalizeForFilter(cmd) {
+  return cmd.trim().replace(/\s+/g, " ");
+}
+function shouldFilter(command, ignoreList) {
+  const normalized2 = normalizeForFilter(command);
+  if (!normalized2) return true;
+  const normalizedIgnore = ignoreList.map(normalizeForFilter);
+  if (normalizedIgnore.includes(normalized2)) return true;
+  const baseCmd = normalized2.split(" ")[0];
+  if (normalizedIgnore.includes(baseCmd)) return true;
+  return false;
+}
+function isDuplicate(command, cwd, lastEvent, dedupWindowMs = 5e3, now = Date.now()) {
+  if (!lastEvent) return false;
+  const lastTime = new Date(lastEvent.captured_at).getTime();
+  return lastEvent.command === normalizeForFilter(command) && lastEvent.cwd === cwd && now - lastTime < dedupWindowMs;
+}
+
+// src/capture/index.ts
+function captureCommand(opts) {
+  const config = readConfig();
+  const { command, cwd, exitCode, durationMs } = opts;
+  if (shouldFilter(command, config.capture.ignore)) return;
+  const last = getLastEvent();
+  if (isDuplicate(command, cwd, last ?? void 0)) return;
+  const safeCommand = redact(normalized, config.redact.extra);
+  const { repoName, branch } = getGitContext(cwd);
+  const { category, metadata } = normalizeCommand(safeCommand);
+  insertEvent({
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    command: safeCommand,
+    cwd,
+    exit_code: exitCode,
+    duration_ms: durationMs,
+    repo_name: repoName,
+    branch,
+    category,
+    metadata: Object.keys(metadata).length > 0 ? JSON.stringify(metadata) : null
+  });
+}
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var import_fs3 = __toESM(require("fs"));
+var isDebug = process.env.CHRONICLE_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_fs3.default.appendFileSync(DEBUG_LOG_PATH, entry);
+  } 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).action((opts) => {
+    try {
+      if (!opts.cmd || !opts.cwd) return;
+      captureCommand({
+        command: opts.cmd,
+        cwd: opts.cwd,
+        exitCode: opts.exit ?? null,
+        durationMs: opts.duration ?? null
+      });
+    } catch (err) {
+      debugLog("_capture", err);
+    }
+  });
+}
+
+// src/cli/init.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+var import_prompts = __toESM(require("prompts"));
+var import_chalk2 = __toESM(require("chalk"));
+var HOOK_START = "# chronicle: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;
+}
+function isHookInstalled(rcFile) {
+  if (!import_fs4.default.existsSync(rcFile)) return false;
+  return import_fs4.default.readFileSync(rcFile, "utf-8").includes(HOOK_START);
+}
+function installHook(rcFile, hookContent) {
+  const backup = `${rcFile}.chronicle-backup-${Date.now()}`;
+  import_fs4.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path3.default.basename(backup)}`);
+  import_fs4.default.appendFileSync(rcFile, `
+${hookContent}
+`);
+}
+function registerInit(program2) {
+  program2.command("init").description("Install shell hooks and set up Chronicle").action(async () => {
+    log.plain(import_chalk2.default.bold("\n  Chronicle \u2014 Developer Work Journal\n"));
+    if (!import_fs4.default.existsSync(CHRONICLE_DIR)) {
+      import_fs4.default.mkdirSync(CHRONICLE_DIR, { recursive: true });
+      log.success(`Created ${CHRONICLE_DIR}`);
+    }
+    getDb();
+    log.success("Database initialized");
+    const shell = detectShell();
+    if (!shell) {
+      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}`);
+      } else {
+        const hookFile = import_path3.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
+        if (!import_fs4.default.existsSync(hookFile)) {
+          log.warn(`Hook template not found at ${hookFile}`);
+        } else {
+          const hookContent = import_fs4.default.readFileSync(hookFile, "utf-8");
+          if (!import_fs4.default.existsSync(shell.rcFile)) import_fs4.default.writeFileSync(shell.rcFile, "");
+          installHook(shell.rcFile, hookContent);
+          log.success(`Shell hook installed in ${shell.rcFile}`);
+        }
+      }
+    }
+    const config = readConfig();
+    if (config.ai.provider) {
+      log.info(`AI provider already configured: ${import_chalk2.default.cyan(config.ai.provider)}`);
+    } else {
+      log.plain("");
+      const { provider } = await (0, import_prompts.default)({
+        type: "select",
+        name: "provider",
+        message: "Which AI provider do you want to use?",
+        choices: [
+          { title: "Anthropic (Claude) \u2014 requires API key", value: "anthropic" },
+          { title: "OpenAI \u2014 requires API key", value: "openai" },
+          { title: "Ollama (local) \u2014 free, runs on your machine", value: "ollama" },
+          { title: "Other (OpenAI-compatible) \u2014 Groq, Together, Mistral\u2026", value: "openai-compatible" },
+          { title: "Skip \u2014 configure later", value: "skip" }
+        ]
+      });
+      if (provider && provider !== "skip") {
+        config.ai.provider = provider;
+        if (provider === "ollama") {
+          log.plain(`
+  ${import_chalk2.default.dim("Make sure Ollama is running: ollama serve")}`);
+          log.plain(`  ${import_chalk2.default.dim("Default model: llama3  (change with: chronicle config set ai.model <model>)")}
+`);
+        } else {
+          const { apiKey } = await (0, import_prompts.default)({
+            type: "password",
+            name: "apiKey",
+            message: `Enter your ${provider === "openai-compatible" ? "" : provider + " "}API key:`
+          });
+          if (apiKey) config.ai.apiKey = apiKey;
+          if (provider === "openai-compatible") {
+            const { baseUrl } = await (0, import_prompts.default)({
+              type: "text",
+              name: "baseUrl",
+              message: "Enter the base URL (e.g. https://api.groq.com/openai/v1):"
+            });
+            if (baseUrl) config.ai.baseUrl = baseUrl;
+          }
+        }
+        writeConfig(config);
+        log.success(`AI provider set to ${import_chalk2.default.cyan(provider)}`);
+      } else if (provider === "skip" || !provider) {
+        log.info("Skipped \u2014 run later: chronicle config set ai.provider <provider>");
+      }
+    }
+    if (!import_fs4.default.existsSync(CONFIG_PATH)) {
+      writeConfig(config);
+      log.success("Config file created");
+    }
+    log.plain("");
+    log.plain(import_chalk2.default.bold("  Setup complete!"));
+    if (shell) {
+      log.plain("");
+      log.plain(`  Activate capture now:  ${import_chalk2.default.cyan(`source ${shell.rcFile}`)}`);
+      log.plain(`  Or restart your terminal.`);
+    }
+    log.plain("");
+    log.plain(`  ${import_chalk2.default.dim("chronicle summary")}   \u2014 generate today's work summary`);
+    log.plain(`  ${import_chalk2.default.dim("chronicle status")}    \u2014 check capture is working`);
+    log.plain("");
+  });
+}
+
+// src/cli/status.ts
+var import_chalk3 = __toESM(require("chalk"));
+
+// src/utils/format.ts
+function formatDuration(minutes) {
+  if (minutes < 60) return `${Math.round(minutes)}m`;
+  const h = Math.floor(minutes / 60);
+  const m = Math.round(minutes % 60);
+  return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+function formatDate(isoString) {
+  return new Date(isoString).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+}
+function todayDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function parseDate(input) {
+  const d = /* @__PURE__ */ new Date(input + "T00:00:00");
+  if (isNaN(d.getTime())) throw new Error(`Invalid date: ${input}`);
+  return input;
+}
+
+// src/cli/status.ts
+function registerStatus(program2) {
+  program2.command("status").description("Show capture status and event counts").action(() => {
+    const config = readConfig();
+    const total = getEventCount();
+    const todayEvents = getEventsForDate(todayDate());
+    const last = getLastEvent();
+    log.plain("");
+    log.plain(import_chalk3.default.bold("  Chronicle Status"));
+    log.plain("");
+    log.plain(`  Capture      ${import_chalk3.default.green("active")}`);
+    log.plain(`  Events today ${import_chalk3.default.cyan(String(todayEvents.length))}`);
+    log.plain(`  Events total ${import_chalk3.default.cyan(String(total))}`);
+    if (last) {
+      log.plain(`  Last event   ${formatDate(last.captured_at)}  ${import_chalk3.default.dim(last.command.slice(0, 60))}`);
+    }
+    log.plain("");
+    log.plain(`  AI provider  ${config.ai.provider ? import_chalk3.default.cyan(config.ai.provider) : import_chalk3.default.yellow("not configured")}`);
+    if (config.ai.model) log.plain(`  Model        ${import_chalk3.default.dim(config.ai.model)}`);
+    log.plain("");
+  });
+}
+
+// src/cli/events.ts
+var import_chalk4 = __toESM(require("chalk"));
+var CATEGORY_COLORS = {
+  code_commit: import_chalk4.default.green,
+  code_push: import_chalk4.default.green,
+  code_pull: import_chalk4.default.blue,
+  branch_switch: import_chalk4.default.blue,
+  dependency_install: import_chalk4.default.yellow,
+  dependency_remove: import_chalk4.default.yellow,
+  test_run: import_chalk4.default.magenta,
+  build: import_chalk4.default.cyan,
+  server_run: import_chalk4.default.cyan,
+  infrastructure: import_chalk4.default.red,
+  script_run: import_chalk4.default.white,
+  environment: import_chalk4.default.gray,
+  git_other: import_chalk4.default.blue,
+  code_merge: import_chalk4.default.green,
+  code_stash: import_chalk4.default.blue,
+  other: import_chalk4.default.gray
+};
+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();
+    if (opts.date) {
+      try {
+        date = parseDate(opts.date);
+      } catch (e) {
+        log.error(e.message);
+        process.exit(1);
+      }
+    }
+    const events = getEventsForDate(date);
+    const limit = opts.limit ?? events.length;
+    if (events.length === 0) {
+      log.plain(`No events captured for ${date}`);
+      return;
+    }
+    log.plain("");
+    log.plain(import_chalk4.default.bold(`  Events for ${date}  (${events.length} total)`));
+    log.plain("");
+    for (const event of events.slice(0, limit)) {
+      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}`);
+    }
+    if (limit < events.length) {
+      log.plain("");
+      log.plain(import_chalk4.default.dim(`  \u2026 and ${events.length - limit} more (remove --limit to see all)`));
+    }
+    log.plain("");
+  });
+}
+
+// src/cli/sessions.ts
+var import_chalk5 = __toESM(require("chalk"));
+
+// src/sessions/grouper.ts
+function splitByIdleGap(events, idleMs) {
+  if (events.length === 0) return [];
+  const groups = [[events[0]]];
+  for (let i = 1; i < events.length; i++) {
+    const prev = new Date(events[i - 1].captured_at).getTime();
+    const curr = new Date(events[i].captured_at).getTime();
+    if (curr - prev >= idleMs) {
+      groups.push([events[i]]);
+    } else {
+      groups[groups.length - 1].push(events[i]);
+    }
+  }
+  return groups;
+}
+function splitByRepo(events) {
+  if (events.length === 0) return [];
+  const groups = [[events[0]]];
+  for (let i = 1; i < events.length; i++) {
+    const prevRepo = events[i - 1].repo_name;
+    const currRepo = events[i].repo_name;
+    if (currRepo !== prevRepo) {
+      groups.push([events[i]]);
+    } else {
+      groups[groups.length - 1].push(events[i]);
+    }
+  }
+  return groups;
+}
+function minutesBetween(start, end) {
+  return (new Date(end).getTime() - new Date(start).getTime()) / 6e4;
+}
+
+// src/sessions/detector.ts
+function getOrBuildSessions(date) {
+  const existing = getSessionsForDate(date);
+  const events = getEventsForDate(date);
+  if (events.length === 0) return [];
+  const cachedEventCount = existing.reduce((sum, s) => sum + s.event_count, 0);
+  if (existing.length > 0 && cachedEventCount === events.length) {
+    return existing.map((s) => ({
+      id: s.id,
+      date: s.date,
+      startedAt: s.started_at,
+      endedAt: s.ended_at,
+      repoName: s.repo_name,
+      durationMinutes: minutesBetween(s.started_at, s.ended_at),
+      eventCount: s.event_count,
+      summary: s.summary,
+      events: []
+      // not needed when using cached
+    }));
+  }
+  clearSessionsForDate(date);
+  return buildSessions(date, events);
+}
+function buildSessions(date, events) {
+  const config = readConfig();
+  const idleMs = config.session.idleTimeout * 60 * 1e3;
+  const sessions = [];
+  const timeGroups = splitByIdleGap(events, idleMs);
+  for (const group of timeGroups) {
+    if (group.length === 0) continue;
+    const repoGroups = splitByRepo(group);
+    for (const repoGroup of repoGroups) {
+      if (repoGroup.length === 0) continue;
+      const first = repoGroup[0];
+      const last = repoGroup[repoGroup.length - 1];
+      const repoName = last.repo_name ?? first.repo_name ?? null;
+      const sessionId = insertSession({
+        date,
+        started_at: first.captured_at,
+        ended_at: last.captured_at,
+        repo_name: repoName,
+        event_count: repoGroup.length,
+        summary: null
+      });
+      for (const event of repoGroup) {
+        insertSessionEvent(sessionId, event.id);
+      }
+      sessions.push({
+        id: sessionId,
+        date,
+        startedAt: first.captured_at,
+        endedAt: last.captured_at,
+        repoName,
+        durationMinutes: minutesBetween(first.captured_at, last.captured_at),
+        eventCount: repoGroup.length,
+        summary: null,
+        events: repoGroup
+      });
+    }
+  }
+  return sessions;
+}
+
+// src/cli/sessions.ts
+function registerSessions(program2) {
+  program2.command("sessions").description("List detected work sessions").option("--date <YYYY-MM-DD>", "date to show sessions for (default: today)").action((opts) => {
+    let date = todayDate();
+    if (opts.date) {
+      try {
+        date = parseDate(opts.date);
+      } catch (e) {
+        log.error(e.message);
+        process.exit(1);
+      }
+    }
+    const sessions = getOrBuildSessions(date);
+    if (sessions.length === 0) {
+      log.plain(`No sessions detected for ${date}`);
+      return;
+    }
+    log.plain("");
+    log.plain(import_chalk5.default.bold(`  Sessions for ${date}  (${sessions.length} session${sessions.length > 1 ? "s" : ""})`));
+    log.plain("");
+    for (const session of sessions) {
+      const start = formatDate(session.startedAt);
+      const end = formatDate(session.endedAt);
+      const duration = formatDuration(session.durationMinutes);
+      const repo = session.repoName ? import_chalk5.default.cyan(session.repoName) : import_chalk5.default.gray("no repo");
+      log.plain(`  ${import_chalk5.default.dim(start)} \u2013 ${import_chalk5.default.dim(end)}  ${repo}  ${import_chalk5.default.dim(duration)}  ${import_chalk5.default.dim(session.eventCount + " events")}`);
+    }
+    log.plain("");
+  });
+}
+
+// src/cli/summary.ts
+var import_chalk6 = __toESM(require("chalk"));
+
+// src/ai/prompt.ts
+var SYSTEM_PROMPT = `You are a technical writer generating a work summary for a software developer.
+
+Rules:
+- Write in past tense, professional tone
+- Describe what was ACCOMPLISHED, not what commands were run
+- Never write literal command names (e.g. do not write "ran npm install" \u2014 write "added HTTP client dependency")
+- Never list commands literally
+- Each bullet point should describe a meaningful unit of work
+- Group related events into single bullet points
+- If tests failed then passed, describe it as "resolved failing tests" not two separate events
+- Return 3-6 bullet points per project section
+- Do not pad or add filler sentences
+- Output only the bullet points grouped under project headers using this exact format:
+
+## <project-name> (<branch>) \u2014 <duration>
+
+- bullet point one
+- bullet point two
+
+If there is no branch, omit the branch. If there are multiple projects, repeat the section for each.`;
+function buildUserMessage(payload) {
+  const lines = [`Date: ${payload.date}`, ""];
+  for (const session of payload.sessions) {
+    lines.push(`Project: ${session.project ?? "unknown"}`);
+    if (session.branch) lines.push(`Branch: ${session.branch}`);
+    lines.push(`Time: ${session.startTime} \u2013 ${session.endTime} (${formatDuration(session.durationMinutes)})`);
+    lines.push("Events:");
+    for (const event of session.events) {
+      const meta = Object.keys(event.metadata).length > 0 ? ` ${JSON.stringify(event.metadata)}` : "";
+      const exitNote = event.exitCode !== null && event.exitCode !== 0 ? ` [exit ${event.exitCode}]` : "";
+      lines.push(`  - ${event.category}${meta}${exitNote}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/ai/providers/anthropic.ts
+var AnthropicProvider = class {
+  apiKey;
+  model;
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+    this.model = model || "claude-haiku-4-5-20251001";
+  }
+  async summarize(payload) {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: 1024,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: "user", content: buildUserMessage(payload) }]
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Anthropic API error ${response.status}: ${body}`);
+    }
+    const data = await response.json();
+    return data.content.find((c) => c.type === "text")?.text ?? "";
+  }
+};
+
+// src/ai/providers/openai.ts
+var OpenAIProvider = class {
+  apiKey;
+  model;
+  baseUrl;
+  constructor(apiKey, model, baseUrl) {
+    this.apiKey = apiKey;
+    this.model = model || "gpt-4o-mini";
+    this.baseUrl = baseUrl || "https://api.openai.com/v1";
+  }
+  async summarize(payload) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: buildUserMessage(payload) }
+        ],
+        max_tokens: 1024
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${body}`);
+    }
+    const data = await response.json();
+    return data.choices[0]?.message?.content ?? "";
+  }
+};
+
+// src/ai/providers/ollama.ts
+var OllamaProvider = class {
+  model;
+  baseUrl;
+  constructor(model, baseUrl) {
+    this.model = model || "llama3";
+    this.baseUrl = baseUrl || "http://localhost:11434";
+  }
+  async summarize(payload) {
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.model,
+        stream: false,
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: buildUserMessage(payload) }
+        ]
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Ollama error ${response.status}: ${body}. Is Ollama running? Try: ollama serve`);
+    }
+    const data = await response.json();
+    return data.message?.content ?? "";
+  }
+};
+
+// src/ai/router.ts
+function getProvider(config) {
+  const { provider, apiKey, model, baseUrl } = config.ai;
+  if (!provider) {
+    throw new Error(
+      "No AI provider configured.\nRun: chronicle config set ai.provider <anthropic|openai|ollama|openai-compatible>"
+    );
+  }
+  switch (provider) {
+    case "anthropic": {
+      if (!apiKey) throw new Error("Anthropic requires an API key.\nRun: chronicle config set ai.apiKey <your-key>");
+      return new AnthropicProvider(apiKey, model || void 0);
+    }
+    case "openai": {
+      if (!apiKey) throw new Error("OpenAI requires an API key.\nRun: chronicle config set ai.apiKey <your-key>");
+      return new OpenAIProvider(apiKey, model || void 0);
+    }
+    case "openai-compatible": {
+      if (!apiKey) throw new Error("This provider requires an API key.\nRun: chronicle config set ai.apiKey <your-key>");
+      if (!baseUrl) throw new Error("openai-compatible requires a base URL.\nRun: chronicle config set ai.baseUrl <url>");
+      return new OpenAIProvider(apiKey, model || void 0, baseUrl);
+    }
+    case "ollama": {
+      return new OllamaProvider(model || void 0, baseUrl || void 0);
+    }
+    default:
+      throw new Error(
+        `Unknown provider: "${provider}"
+Supported providers: anthropic, openai, ollama, openai-compatible`
+      );
+  }
+}
+
+// src/cli/summary.ts
+function eventRowToPayload(row) {
+  let metadata = {};
+  try {
+    if (row.metadata) metadata = JSON.parse(row.metadata);
+  } catch {
+  }
+  return {
+    category: row.category,
+    metadata,
+    exitCode: row.exit_code,
+    durationMs: row.duration_ms
+  };
+}
+function registerSummary(program2) {
+  program2.command("summary").description("Generate an AI work summary").option("--date <YYYY-MM-DD>", "date to summarize (default: today)").option("--week", "summarize the current week").option("--fresh", "bypass cache and regenerate").action(async (opts) => {
+    let date = todayDate();
+    if (opts.date) {
+      try {
+        date = parseDate(opts.date);
+      } catch (e) {
+        log.error(e.message);
+        process.exit(1);
+      }
+    }
+    const sessions = getOrBuildSessions(date);
+    if (sessions.length === 0) {
+      log.plain(`No activity captured for ${date}`);
+      return;
+    }
+    if (!opts.fresh) {
+      const allCached = sessions.every((s) => s.summary);
+      if (allCached) {
+        log.plain("");
+        for (const s of sessions) {
+          log.plain(s.summary);
+        }
+        log.plain("");
+        log.plain(import_chalk6.default.dim("  (cached \u2014 use --fresh to regenerate)"));
+        return;
+      }
+    }
+    const config = readConfig();
+    let provider;
+    try {
+      provider = getProvider(config);
+    } catch (e) {
+      log.error(e.message);
+      process.exit(1);
+    }
+    const sessionPayloads = sessions.map((s) => ({
+      date,
+      project: s.repoName,
+      branch: s.events[0]?.branch ?? null,
+      startTime: formatDate(s.startedAt),
+      endTime: formatDate(s.endedAt),
+      durationMinutes: s.durationMinutes,
+      events: s.events.map(eventRowToPayload)
+    }));
+    const payload = { date, sessions: sessionPayloads };
+    log.plain("");
+    log.info(`Generating summary via ${import_chalk6.default.cyan(config.ai.provider)}\u2026`);
+    try {
+      const summary = await provider.summarize(payload);
+      log.plain("");
+      log.plain(summary);
+      log.plain("");
+      if (sessions[0]) {
+        updateSessionSummary(sessions[0].id, summary);
+      }
+    } catch (e) {
+      log.error(`Summary failed [${config.ai.provider}]: ${e.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/export.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+function eventRowToPayload2(row) {
+  let metadata = {};
+  try {
+    if (row.metadata) metadata = JSON.parse(row.metadata);
+  } catch {
+  }
+  return { category: row.category, metadata, exitCode: row.exit_code, durationMs: row.duration_ms };
+}
+function registerExport(program2) {
+  program2.command("export").description("Export work summary as a markdown file").option("--date <YYYY-MM-DD>", "date to export (default: today)").option("--output <path>", "output file path (default: ~/.chronicle/exports/)").action(async (opts) => {
+    let date = todayDate();
+    if (opts.date) {
+      try {
+        date = parseDate(opts.date);
+      } catch (e) {
+        log.error(e.message);
+        process.exit(1);
+      }
+    }
+    const sessions = getOrBuildSessions(date);
+    if (sessions.length === 0) {
+      log.plain(`No activity captured for ${date}`);
+      return;
+    }
+    const config = readConfig();
+    let provider;
+    try {
+      provider = getProvider(config);
+    } catch (e) {
+      log.error(e.message);
+      process.exit(1);
+    }
+    const sessionPayloads = sessions.map((s) => ({
+      date,
+      project: s.repoName,
+      branch: s.events[0]?.branch ?? null,
+      startTime: formatDate(s.startedAt),
+      endTime: formatDate(s.endedAt),
+      durationMinutes: s.durationMinutes,
+      events: s.events.map(eventRowToPayload2)
+    }));
+    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_path4.default.join(EXPORTS_DIR, `chronicle-${date}.md`);
+    if (!import_fs5.default.existsSync(EXPORTS_DIR)) import_fs5.default.mkdirSync(EXPORTS_DIR, { recursive: true });
+    import_fs5.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
+
+${summary}
+`, "utf-8");
+    log.success(`Saved: ${outputPath}`);
+  });
+}
+
+// src/cli/config.ts
+var import_chalk7 = __toESM(require("chalk"));
+function registerConfig(program2) {
+  const configCmd = program2.command("config").description("View or update Chronicle configuration").action(() => {
+    const config = readConfig();
+    log.plain("");
+    log.plain(import_chalk7.default.bold("  Chronicle Config"));
+    log.plain("");
+    printConfig(config, "  ");
+    log.plain("");
+  });
+  configCmd.command("set <key> <value>").description("Set a config value (e.g. chronicle config set ai.provider anthropic)").action((key, value) => {
+    const config = readConfig();
+    const updated = setConfigValue(config, key, value);
+    writeConfig(updated);
+    log.success(`Set ${import_chalk7.default.cyan(key)} = ${import_chalk7.default.yellow(value)}`);
+  });
+  configCmd.command("get <key>").description("Get a config value").action((key) => {
+    const config = readConfig();
+    const value = getConfigValue(config, key);
+    if (value === void 0) {
+      log.warn(`Key not found: ${key}`);
+    } else {
+      log.plain(String(value));
+    }
+  });
+}
+function printConfig(obj, indent) {
+  if (typeof obj !== "object" || obj === null) return;
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      log.plain(`${indent}${import_chalk7.default.bold(key)}:`);
+      printConfig(value, indent + "  ");
+    } else {
+      const display = Array.isArray(value) ? `[${value.join(", ")}]` : String(value) || import_chalk7.default.dim("(not set)");
+      log.plain(`${indent}${import_chalk7.default.dim(key)}: ${import_chalk7.default.yellow(display)}`);
+    }
+  }
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("chronicle").description("Automatic developer work journal").version("0.1.0");
+registerCapture(program);
+registerInit(program);
+registerStatus(program);
+registerEvents(program);
+registerSessions(program);
+registerSummary(program);
+registerExport(program);
+registerConfig(program);
+program.parse();
+//# sourceMappingURL=index.js.map