stickyinc 0.5.2

package/dist/bundle/stickyinc-watch.mjs

@@ -0,0 +1,1013 @@
+#!/usr/bin/env node
+
+// src/watcher.ts
+import {
+  closeSync,
+  existsSync as existsSync3,
+  openSync,
+  readFileSync as readFileSync3,
+  readSync,
+  readdirSync,
+  statSync as statSync2,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+
+// src/db.ts
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function dbPath() {
+  const override = process.env.STICKYINC_DB;
+  if (!override) return join(homedir(), ".stickyinc", "tasks.db");
+  return resolve(override.replace(/^~(?=$|[\\/])/, homedir()));
+}
+var DB_PATH = dbPath();
+mkdirSync(dirname(DB_PATH), { recursive: true });
+var db = new DatabaseSync(DB_PATH);
+db.exec(`PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;`);
+function inTransaction(fn) {
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const result = fn();
+    db.exec("COMMIT");
+    return result;
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+db.exec(`
+  CREATE TABLE IF NOT EXISTS tasks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    uuid TEXT,
+    text TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at TEXT,
+    due_at TEXT,
+    source TEXT NOT NULL DEFAULT 'claude',
+    fingerprint TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_tasks_completed ON tasks(completed_at);
+  CREATE INDEX IF NOT EXISTS idx_tasks_due ON tasks(due_at);
+
+  CREATE TABLE IF NOT EXISTS meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS task_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    event_uuid TEXT NOT NULL UNIQUE,
+    task_uuid TEXT NOT NULL,
+    op TEXT NOT NULL CHECK (op IN ('create','complete','uncomplete','edit','delete')),
+    payload TEXT,
+    device_id TEXT NOT NULL,
+    ts TEXT NOT NULL DEFAULT (datetime('now')),
+    lamport INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_events_task ON task_events(task_uuid);
+  CREATE INDEX IF NOT EXISTS idx_task_events_lamport ON task_events(device_id, lamport);
+`);
+{
+  const cols = db.prepare(`PRAGMA table_info(tasks)`).all();
+  if (!cols.some((c) => c.name === "fingerprint")) {
+    db.exec(`ALTER TABLE tasks ADD COLUMN fingerprint TEXT`);
+  }
+  if (!cols.some((c) => c.name === "uuid")) {
+    db.exec(`ALTER TABLE tasks ADD COLUMN uuid TEXT`);
+  }
+  const pending = db.prepare(`SELECT id FROM tasks WHERE uuid IS NULL`).all();
+  if (pending.length > 0) {
+    const setUuid = db.prepare(`UPDATE tasks SET uuid = ? WHERE id = ?`);
+    inTransaction(() => {
+      for (const row of pending) setUuid.run(randomUUID(), row.id);
+    });
+  }
+}
+db.exec(`
+  CREATE INDEX IF NOT EXISTS idx_tasks_fingerprint ON tasks(fingerprint);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_uuid ON tasks(uuid);
+`);
+function ensureDeviceId() {
+  const row = db.prepare(`SELECT value FROM meta WHERE key = 'device_id'`).get();
+  if (row) return row.value;
+  const id = randomUUID();
+  db.prepare(
+    `INSERT OR IGNORE INTO meta (key, value) VALUES ('device_id', ?)`
+  ).run(id);
+  const final = db.prepare(`SELECT value FROM meta WHERE key = 'device_id'`).get();
+  return final.value;
+}
+var DEVICE_ID = ensureDeviceId();
+function nextLamport() {
+  const row = db.prepare(`SELECT MAX(lamport) as m FROM task_events WHERE device_id = ?`).get(DEVICE_ID);
+  return (row.m ?? 0) + 1;
+}
+var insertEventStmt = db.prepare(
+  `INSERT INTO task_events (event_uuid, task_uuid, op, payload, device_id, lamport)
+   VALUES (?, ?, ?, ?, ?, ?)`
+);
+function recordEvent(op, taskUuid, payload) {
+  insertEventStmt.run(
+    randomUUID(),
+    taskUuid,
+    op,
+    payload === null ? null : JSON.stringify(payload),
+    DEVICE_ID,
+    nextLamport()
+  );
+}
+var insertTaskStmt = db.prepare(
+  `INSERT INTO tasks (uuid, text, due_at, source, fingerprint) VALUES (?, ?, ?, ?, ?) RETURNING *`
+);
+var findOpenByFingerprintStmt = db.prepare(
+  `SELECT * FROM tasks WHERE fingerprint = ? AND completed_at IS NULL LIMIT 1`
+);
+var countDoneTodayStmt = db.prepare(
+  `SELECT COUNT(*) as n FROM tasks WHERE completed_at IS NOT NULL
+     AND date(completed_at, 'localtime') = date('now', 'localtime')`
+);
+var selectOpenStmt = db.prepare(
+  `SELECT * FROM tasks WHERE completed_at IS NULL ORDER BY
+     CASE WHEN due_at IS NULL THEN 1 ELSE 0 END, due_at ASC, created_at ASC`
+);
+var selectAllStmt = db.prepare(
+  `SELECT * FROM tasks ORDER BY created_at DESC LIMIT ?`
+);
+var selectRecentDoneStmt = db.prepare(
+  `SELECT * FROM tasks
+   WHERE completed_at IS NOT NULL
+     AND completed_at >= datetime('now', ?)
+   ORDER BY completed_at DESC`
+);
+var selectArchivedStmt = db.prepare(
+  `SELECT * FROM tasks
+   WHERE completed_at IS NOT NULL
+     AND completed_at < datetime('now', ?)
+   ORDER BY completed_at DESC
+   LIMIT ?`
+);
+var completeTaskFindStmt = db.prepare(
+  `SELECT uuid, completed_at FROM tasks WHERE id = ?`
+);
+var completeTaskUpdateStmt = db.prepare(
+  `UPDATE tasks SET completed_at = datetime('now') WHERE id = ? AND completed_at IS NULL`
+);
+var getTaskStmt = db.prepare(`SELECT * FROM tasks WHERE id = ?`);
+function fingerprint(text) {
+  return createHash("sha256").update(text.toLowerCase().replace(/\s+/g, " ").trim()).digest("hex").slice(0, 16);
+}
+function addTaskUnique(text, dueAt = null, source = "claude") {
+  const fp = fingerprint(text);
+  return inTransaction(() => {
+    const existing = findOpenByFingerprintStmt.get(fp);
+    if (existing) return { task: existing, inserted: false };
+    const taskUuid = randomUUID();
+    const task = insertTaskStmt.get(taskUuid, text, dueAt, source, fp);
+    recordEvent("create", taskUuid, { text, due_at: dueAt, source });
+    return { task, inserted: true };
+  });
+}
+
+// src/dates.ts
+function toStoredDue(input) {
+  const s = input.trim();
+  const d = /^\d{4}-\d{2}-\d{2}$/.test(s) ? /* @__PURE__ */ new Date(`${s}T09:00:00`) : new Date(s);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function timeContext(now = /* @__PURE__ */ new Date()) {
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const weekday = (d) => d.toLocaleDateString("en-US", { weekday: "long" });
+  const ymd = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+  const hm = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+  const week = Array.from({ length: 7 }, (_, i) => {
+    const d = new Date(now.getFullYear(), now.getMonth(), now.getDate() + i + 1, 12);
+    return `${weekday(d)} ${ymd(d)}`;
+  });
+  return `Now (user's local time, ${tz}): ${weekday(now)} ${ymd(now)} ${hm}.
+The next 7 days: ${week.join(", ")}.`;
+}
+
+// src/providers/index.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+
+// src/providers/types.ts
+var CHAT_TIMEOUT_MS = Number(process.env.STICKYINC_LLM_TIMEOUT_MS) || 9e4;
+
+// src/providers/anthropic.ts
+var AnthropicProvider = class {
+  name = "anthropic";
+  model;
+  apiKey;
+  baseUrl;
+  constructor(cfg) {
+    this.apiKey = cfg.api_key;
+    this.model = cfg.model ?? "claude-haiku-4-5-20251001";
+    this.baseUrl = cfg.base_url ?? "https://api.anthropic.com";
+  }
+  async chat(opts2) {
+    const body = {
+      model: this.model,
+      max_tokens: opts2.max_tokens ?? 1024,
+      messages: opts2.messages
+    };
+    if (opts2.system) body.system = opts2.system;
+    if (typeof opts2.temperature === "number") body.temperature = opts2.temperature;
+    const res = await fetch(`${this.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(CHAT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      throw new Error(`Anthropic API error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    const text = data.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+    return {
+      content: text,
+      model: data.model,
+      provider: this.name,
+      usage: { input: data.usage.input_tokens, output: data.usage.output_tokens }
+    };
+  }
+};
+
+// src/providers/openai.ts
+var OpenAICompatProvider = class {
+  name;
+  model;
+  apiKey;
+  baseUrl;
+  extraHeaders;
+  constructor(cfg) {
+    this.apiKey = cfg.api_key;
+    this.model = cfg.model;
+    this.baseUrl = cfg.base_url.replace(/\/+$/, "");
+    this.name = cfg.provider_label ?? "openai";
+    this.extraHeaders = cfg.extra_headers ?? {};
+  }
+  async chat(opts2) {
+    const messages = [
+      ...opts2.system ? [{ role: "system", content: opts2.system }] : [],
+      ...opts2.messages
+    ];
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: opts2.max_tokens ?? 1024
+    };
+    if (typeof opts2.temperature === "number") body.temperature = opts2.temperature;
+    if (opts2.response_format === "json") body.response_format = { type: "json_object" };
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiKey}`,
+        "content-type": "application/json",
+        ...this.extraHeaders
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(CHAT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      throw new Error(`${this.name} API error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    return {
+      content: data.choices[0]?.message.content ?? "",
+      model: data.model ?? this.model,
+      provider: this.name,
+      usage: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
+    };
+  }
+};
+
+// src/providers/claude_code.ts
+import { spawn } from "node:child_process";
+
+// src/providers/which.ts
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir as homedir2, userInfo } from "node:os";
+import { delimiter, join as join2 } from "node:path";
+var NAME_PATTERN = /^[a-z0-9_-]+$/;
+function wellKnownDirs() {
+  const home = homedir2();
+  return [
+    join2(home, ".local", "bin"),
+    // Claude Code's native installer, codex, pipx, uv
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    join2(home, ".npm-global", "bin"),
+    join2(home, ".volta", "bin"),
+    join2(home, ".bun", "bin")
+  ];
+}
+function whichBinary(name) {
+  const paths = (process.env.PATH ?? "").split(delimiter);
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  for (const dir of paths) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const candidate = join2(dir, name + ext);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  if (process.platform === "win32") return null;
+  for (const dir of wellKnownDirs()) {
+    const candidate = join2(dir, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  if (process.platform !== "darwin") return null;
+  if (!NAME_PATTERN.test(name)) return null;
+  try {
+    const shell = userInfo().shell || process.env.SHELL || "/bin/zsh";
+    const result = spawnSync(shell, ["-ilc", `command -v ${name}`], {
+      timeout: 3e3,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const lines = (result.stdout ?? "").split("\n").map((l) => l.trim());
+    for (const line of lines.reverse()) {
+      if (line.startsWith("/") && existsSync(line)) return line;
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/providers/claude_code.ts
+function findClaudeBinary() {
+  return whichBinary("claude");
+}
+var ClaudeCodeProvider = class {
+  name = "claude-code";
+  model;
+  binary;
+  constructor(cfg) {
+    this.binary = cfg.binary;
+    this.model = cfg.model ?? "haiku";
+  }
+  async chat(opts2) {
+    const prompt = mergePrompt(opts2);
+    const args2 = [
+      "-p",
+      "--output-format",
+      "text",
+      "--no-session-persistence",
+      "--strict-mcp-config",
+      "--tools",
+      ""
+    ];
+    if (this.model) args2.push("--model", this.model);
+    return new Promise((resolve2, reject) => {
+      const child = spawn(this.binary, args2, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const timer = setTimeout(() => {
+        child.kill();
+        reject(new Error(`claude -p gave no answer within ${CHAT_TIMEOUT_MS / 1e3}s`));
+      }, CHAT_TIMEOUT_MS);
+      let out = "";
+      let err = "";
+      child.stdout.setEncoding("utf8");
+      child.stderr.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => out += chunk);
+      child.stderr.on("data", (chunk) => err += chunk);
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        reject(e);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code !== 0) {
+          const stderrSnip = err.trim().slice(0, 400);
+          const stdoutSnip = out.trim().slice(0, 400);
+          reject(
+            new Error(
+              `claude -p exited ${code}: ${stderrSnip || stdoutSnip || "(no output)"}`
+            )
+          );
+          return;
+        }
+        resolve2({
+          content: out.trim(),
+          model: this.model,
+          provider: this.name
+        });
+      });
+      child.stdin.write(prompt);
+      child.stdin.end();
+    });
+  }
+};
+function mergePrompt(opts2) {
+  const parts = [];
+  if (opts2.system) parts.push(opts2.system);
+  for (const m of opts2.messages) {
+    if (m.role === "user") parts.push(m.content);
+    else parts.push(`[previous assistant reply]
+${m.content}`);
+  }
+  return parts.join("\n\n");
+}
+
+// src/providers/codex.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+function findCodexBinary() {
+  return whichBinary("codex");
+}
+var CodexProvider = class {
+  name = "codex";
+  model;
+  binary;
+  explicitModel;
+  constructor(cfg) {
+    this.binary = cfg.binary;
+    this.model = cfg.model ?? "chatgpt-default";
+    this.explicitModel = cfg.model ?? null;
+  }
+  async chat(opts2) {
+    const prompt = mergePrompt2(opts2);
+    const tmpDir = mkdtempSync(join3(tmpdir(), "stickyinc-codex-"));
+    const outFile = join3(tmpDir, "last.txt");
+    const args2 = [
+      "exec",
+      "--skip-git-repo-check",
+      "--sandbox",
+      "read-only",
+      "--output-last-message",
+      outFile
+    ];
+    if (this.explicitModel) args2.push("--model", this.explicitModel);
+    args2.push(prompt);
+    const cleanup = () => {
+      try {
+        rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    };
+    return new Promise((resolve2, reject) => {
+      const child = spawn2(this.binary, args2, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const timer = setTimeout(() => {
+        child.kill();
+        reject(new Error(`codex exec gave no answer within ${CHAT_TIMEOUT_MS / 1e3}s`));
+      }, CHAT_TIMEOUT_MS);
+      let out = "";
+      let err = "";
+      child.stdout.setEncoding("utf8");
+      child.stderr.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => out += chunk);
+      child.stderr.on("data", (chunk) => err += chunk);
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        cleanup();
+        reject(e);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code !== 0) {
+          cleanup();
+          const stderrSnip = err.trim().slice(0, 400);
+          const stdoutSnip = out.trim().slice(0, 400);
+          reject(
+            new Error(
+              `codex exec exited ${code}: ${stderrSnip || stdoutSnip || "(no output)"}`
+            )
+          );
+          return;
+        }
+        let content = "";
+        try {
+          content = readFileSync(outFile, "utf8").trim();
+        } catch {
+          content = out.trim();
+        }
+        cleanup();
+        resolve2({
+          content,
+          model: this.model,
+          provider: this.name
+        });
+      });
+    });
+  }
+};
+function mergePrompt2(opts2) {
+  const parts = [];
+  if (opts2.system) parts.push(opts2.system);
+  for (const m of opts2.messages) {
+    if (m.role === "user") parts.push(m.content);
+    else parts.push(`[previous assistant reply]
+${m.content}`);
+  }
+  return parts.join("\n\n");
+}
+
+// src/providers/gemini.ts
+import { spawn as spawn3 } from "node:child_process";
+function findGeminiBinary() {
+  return whichBinary("gemini");
+}
+var GeminiProvider = class {
+  name = "gemini";
+  model;
+  binary;
+  explicitModel;
+  constructor(cfg) {
+    this.binary = cfg.binary;
+    this.model = cfg.model ?? "gemini-default";
+    this.explicitModel = cfg.model ?? null;
+  }
+  async chat(opts2) {
+    const prompt = mergePrompt3(opts2);
+    const args2 = [];
+    if (this.explicitModel) args2.push("--model", this.explicitModel);
+    args2.push("-p", prompt);
+    return new Promise((resolve2, reject) => {
+      const child = spawn3(this.binary, args2, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const timer = setTimeout(() => {
+        child.kill();
+        reject(new Error(`gemini -p gave no answer within ${CHAT_TIMEOUT_MS / 1e3}s`));
+      }, CHAT_TIMEOUT_MS);
+      let out = "";
+      let err = "";
+      child.stdout.setEncoding("utf8");
+      child.stderr.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => out += chunk);
+      child.stderr.on("data", (chunk) => err += chunk);
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        reject(e);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code !== 0) {
+          const stderrSnip = err.trim().slice(0, 400);
+          const stdoutSnip = out.trim().slice(0, 400);
+          reject(
+            new Error(
+              `gemini -p exited ${code}: ${stderrSnip || stdoutSnip || "(no output)"}`
+            )
+          );
+          return;
+        }
+        resolve2({
+          content: out.trim(),
+          model: this.model,
+          provider: this.name
+        });
+      });
+    });
+  }
+};
+function mergePrompt3(opts2) {
+  const parts = [];
+  if (opts2.system) parts.push(opts2.system);
+  for (const m of opts2.messages) {
+    if (m.role === "user") parts.push(m.content);
+    else parts.push(`[previous assistant reply]
+${m.content}`);
+  }
+  return parts.join("\n\n");
+}
+
+// src/providers/local.ts
+var LOCAL_ENDPOINTS = [
+  { url: "http://127.0.0.1:11434", kind: "ollama" },
+  { url: "http://127.0.0.1:1234", kind: "lm-studio" }
+];
+async function probeLocalProvider(overrideModel) {
+  for (const ep of LOCAL_ENDPOINTS) {
+    const model = await probe(ep);
+    if (model) {
+      return new OpenAICompatProvider({
+        api_key: "local",
+        model: overrideModel ?? model,
+        base_url: `${ep.url}/v1`,
+        provider_label: ep.kind
+      });
+    }
+  }
+  return null;
+}
+async function probe(ep) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 500);
+  try {
+    if (ep.kind === "ollama") {
+      const r2 = await fetch(`${ep.url}/api/tags`, { signal: controller.signal });
+      if (!r2.ok) return null;
+      const data2 = await r2.json();
+      return data2.models?.[0]?.name ?? null;
+    }
+    const r = await fetch(`${ep.url}/v1/models`, { signal: controller.signal });
+    if (!r.ok) return null;
+    const data = await r.json();
+    return data.data?.[0]?.id ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/providers/index.ts
+var CONFIG_PATH = join4(homedir3(), ".stickyinc", "llm.json");
+function readConfigFile() {
+  if (!existsSync2(CONFIG_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync2(CONFIG_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var cached;
+function configMtime() {
+  try {
+    return statSync(CONFIG_PATH).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+async function resolveLLMProvider() {
+  const mtime = configMtime();
+  if (cached && cached.configMtime === mtime) return cached.provider;
+  const provider = await resolveInternal();
+  cached = provider ? { provider, configMtime: mtime } : void 0;
+  return provider;
+}
+async function resolveInternal() {
+  const cfg = readConfigFile();
+  if (cfg) {
+    switch (cfg.provider) {
+      case "anthropic": {
+        const key = cfg.api_key ?? process.env.ANTHROPIC_API_KEY;
+        if (!key) return null;
+        return new AnthropicProvider({ api_key: key, model: cfg.model, base_url: cfg.base_url });
+      }
+      case "openrouter": {
+        const key = cfg.api_key ?? process.env.OPENROUTER_API_KEY;
+        if (!key) return null;
+        return new OpenAICompatProvider({
+          api_key: key,
+          model: cfg.model ?? "anthropic/claude-haiku-4.5",
+          base_url: cfg.base_url ?? "https://openrouter.ai/api/v1",
+          provider_label: "openrouter",
+          extra_headers: {
+            "HTTP-Referer": "https://github.com/Astralchemist/stickyinc",
+            "X-Title": "StickyInc",
+            ...cfg.extra_headers ?? {}
+          }
+        });
+      }
+      case "openai": {
+        const key = cfg.api_key ?? process.env.OPENAI_API_KEY;
+        if (!key) return null;
+        return new OpenAICompatProvider({
+          api_key: key,
+          model: cfg.model ?? "gpt-4o-mini",
+          base_url: cfg.base_url ?? "https://api.openai.com/v1",
+          provider_label: "openai"
+        });
+      }
+      case "compat": {
+        if (!cfg.api_key || !cfg.model || !cfg.base_url) return null;
+        return new OpenAICompatProvider({
+          api_key: cfg.api_key,
+          model: cfg.model,
+          base_url: cfg.base_url,
+          provider_label: "compat",
+          extra_headers: cfg.extra_headers
+        });
+      }
+      case "claude-code": {
+        const binary = findClaudeBinary();
+        if (!binary) return null;
+        return new ClaudeCodeProvider({ binary, model: cfg.model });
+      }
+      case "codex": {
+        const binary = findCodexBinary();
+        if (!binary) return null;
+        return new CodexProvider({ binary, model: cfg.model });
+      }
+      case "gemini": {
+        const binary = findGeminiBinary();
+        if (!binary) return null;
+        return new GeminiProvider({ binary, model: cfg.model });
+      }
+      case "local": {
+        return probeLocalProvider(cfg.model);
+      }
+    }
+  }
+  if (process.env.OPENROUTER_API_KEY) {
+    return new OpenAICompatProvider({
+      api_key: process.env.OPENROUTER_API_KEY,
+      model: process.env.STICKYINC_MODEL ?? "anthropic/claude-haiku-4.5",
+      base_url: "https://openrouter.ai/api/v1",
+      provider_label: "openrouter",
+      extra_headers: {
+        "HTTP-Referer": "https://github.com/Astralchemist/stickyinc",
+        "X-Title": "StickyInc"
+      }
+    });
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    return new AnthropicProvider({
+      api_key: process.env.ANTHROPIC_API_KEY,
+      model: process.env.STICKYINC_MODEL
+    });
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return new OpenAICompatProvider({
+      api_key: process.env.OPENAI_API_KEY,
+      model: process.env.STICKYINC_MODEL ?? "gpt-4o-mini",
+      base_url: "https://api.openai.com/v1",
+      provider_label: "openai"
+    });
+  }
+  const claudeBin = findClaudeBinary();
+  if (claudeBin) {
+    return new ClaudeCodeProvider({ binary: claudeBin, model: process.env.STICKYINC_MODEL });
+  }
+  const codexBin = findCodexBinary();
+  if (codexBin) {
+    return new CodexProvider({ binary: codexBin, model: process.env.STICKYINC_MODEL });
+  }
+  const geminiBin = findGeminiBinary();
+  if (geminiBin) {
+    return new GeminiProvider({ binary: geminiBin, model: process.env.STICKYINC_MODEL });
+  }
+  const local = await probeLocalProvider(process.env.STICKYINC_MODEL);
+  if (local) return local;
+  return null;
+}
+
+// src/watcher.ts
+var CLAUDE_PROJECTS = join5(homedir4(), ".claude", "projects");
+var STATE_FILE = join5(homedir4(), ".stickyinc", "watcher-state.json");
+function loadState() {
+  if (!existsSync3(STATE_FILE)) return { files: {} };
+  try {
+    return JSON.parse(readFileSync3(STATE_FILE, "utf8"));
+  } catch {
+    return { files: {} };
+  }
+}
+function saveState(s) {
+  writeFileSync(STATE_FILE, JSON.stringify(s, null, 2));
+}
+function readBytes(file, start, end) {
+  const buf = Buffer.alloc(end - start);
+  const fd = openSync(file, "r");
+  try {
+    let read = 0;
+    while (read < buf.length) {
+      const n = readSync(fd, buf, read, buf.length - read, start + read);
+      if (n === 0) break;
+      read += n;
+    }
+    return buf.subarray(0, read);
+  } finally {
+    closeSync(fd);
+  }
+}
+function listJsonlFiles() {
+  if (!existsSync3(CLAUDE_PROJECTS)) return [];
+  const out = [];
+  for (const dir of readdirSync(CLAUDE_PROJECTS)) {
+    const full = join5(CLAUDE_PROJECTS, dir);
+    try {
+      if (!statSync2(full).isDirectory()) continue;
+      for (const f of readdirSync(full)) {
+        if (f.endsWith(".jsonl")) out.push(join5(full, f));
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function extractText(message) {
+  const c = message?.content;
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) {
+    return c.map((b) => {
+      if (typeof b === "string") return b;
+      if (b && typeof b === "object" && "text" in b) return String(b.text ?? "");
+      return "";
+    }).join(" ").trim();
+  }
+  return "";
+}
+var EXTRACTION_SYSTEM = `You extract actionable commitments from a message.
+
+A "commitment" is something the speaker said they will or should do. Examples:
+  - "I need to call the dentist" \u2192 { "text": "Call the dentist", "due_at": null }
+  - "Let me email Sarah tomorrow" \u2192 { "text": "Email Sarah", "due_at": "<tomorrow's date>T09:00" }
+
+Ignore:
+  - Hypotheticals ("I could do X")
+  - Rhetorical or past-tense references
+  - Generic questions or musings
+
+Output ONLY a JSON object, no prose:
+{ "commitments": [{ "text": "...", "due_at": "<local YYYY-MM-DDTHH:MM or null>" }] }
+
+Empty array if nothing qualifies. due_at is the user's local time, with no offset or Z; take weekdays and "tomorrow" from the dates listed below. If a date has no time, use 09:00.`;
+function stripFences(s) {
+  return s.replace(/^\s*```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+}
+function parseCommitments(raw) {
+  let cleaned = stripFences(raw);
+  let obj;
+  try {
+    obj = JSON.parse(cleaned);
+  } catch {
+    const m = cleaned.match(/\{[\s\S]*\}/);
+    if (!m) return [];
+    try {
+      obj = JSON.parse(m[0]);
+    } catch {
+      return [];
+    }
+  }
+  if (!obj || typeof obj !== "object") return [];
+  const arr = obj.commitments;
+  if (!Array.isArray(arr)) return [];
+  const out = [];
+  for (const c of arr) {
+    if (!c || typeof c !== "object") continue;
+    const text = c.text;
+    const due = c.due_at;
+    if (typeof text === "string" && text.trim().length > 0) {
+      out.push({
+        text: text.trim(),
+        due_at: typeof due === "string" ? toStoredDue(due) : null
+      });
+    }
+  }
+  return out;
+}
+async function extract(provider, speaker, text) {
+  if (text.trim().length < 4) return [];
+  const res = await provider.chat({
+    system: EXTRACTION_SYSTEM,
+    messages: [
+      {
+        role: "user",
+        content: `${timeContext()}
+Speaker: ${speaker}
+
+Message:
+${text.slice(0, 4e3)}`
+      }
+    ],
+    response_format: "json",
+    max_tokens: 400,
+    temperature: 0
+  });
+  return parseCommitments(res.content);
+}
+async function runWatcher(opts2 = {}) {
+  const interval = opts2.intervalMs ?? 3e3;
+  const includeUser = opts2.includeUser ?? true;
+  const includeAssistant = opts2.includeAssistant ?? false;
+  const verbose = opts2.verbose ?? true;
+  const provider = await resolveLLMProvider();
+  if (!provider) {
+    console.error(
+      "No LLM configured. StickyInc auto-uses whatever is on this machine: claude / codex / gemini CLI (subscription), Ollama or LM Studio (local), or an API key via OPENROUTER_API_KEY / ANTHROPIC_API_KEY / OPENAI_API_KEY. Or create ~/.stickyinc/llm.json."
+    );
+    process.exit(1);
+  }
+  if (!existsSync3(CLAUDE_PROJECTS)) {
+    console.error(`No Claude Code transcripts at ${CLAUDE_PROJECTS}. Is Claude Code installed?`);
+    process.exit(1);
+  }
+  console.error(
+    `StickyInc watcher running.
+  Transcripts: ${CLAUDE_PROJECTS}
+  Provider:    ${provider.name} (${provider.model})
+  Extracting:  ${[includeUser && "user", includeAssistant && "assistant"].filter(Boolean).join(", ")}
+  Poll:        ${interval}ms
+  Press Ctrl-C to stop.
+`
+  );
+  const state = loadState();
+  for (const f of listJsonlFiles()) {
+    if (!state.files[f]) {
+      const st = statSync2(f);
+      state.files[f] = { size: st.size, mtime: st.mtimeMs };
+    }
+  }
+  saveState(state);
+  const tick = async () => {
+    for (const file of listJsonlFiles()) {
+      let st;
+      try {
+        st = statSync2(file);
+      } catch {
+        continue;
+      }
+      const prev = state.files[file] ?? { size: 0, mtime: 0 };
+      if (st.size < prev.size) prev.size = 0;
+      if (st.size === prev.size) continue;
+      const chunk = readBytes(file, prev.size, st.size);
+      const end = chunk.lastIndexOf(10) + 1;
+      if (end === 0) continue;
+      const slice = chunk.subarray(0, end).toString("utf8");
+      prev.size += end;
+      prev.mtime = st.mtimeMs;
+      state.files[file] = prev;
+      for (const line of slice.split("\n")) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const role = obj.message?.role;
+        if (obj.type !== "user" && obj.type !== "assistant") continue;
+        if (role === "user" && !includeUser) continue;
+        if (role === "assistant" && !includeAssistant) continue;
+        const text = extractText(obj.message);
+        if (!text) continue;
+        try {
+          const commitments = await extract(provider, role ?? "user", text);
+          for (const c of commitments) {
+            const { task, inserted } = addTaskUnique(c.text, c.due_at, "passive-extract");
+            if (inserted && verbose) {
+              console.error(`  + #${task.id} ${c.text}${c.due_at ? ` (due ${c.due_at})` : ""}`);
+            } else if (!inserted && verbose) {
+              console.error(`  ~ dup #${task.id} ${c.text}`);
+            }
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (verbose) console.error(`  ! extract failed: ${msg}`);
+        }
+      }
+      saveState(state);
+    }
+  };
+  let stopping = false;
+  const onExit = () => {
+    stopping = true;
+    saveState(state);
+    console.error("\nwatcher stopped.");
+    process.exit(0);
+  };
+  process.on("SIGINT", onExit);
+  process.on("SIGTERM", onExit);
+  const parentPid = process.ppid;
+  while (!stopping) {
+    if (opts2.exitWithParent && process.ppid !== parentPid) {
+      console.error("parent exited; watcher stopping.");
+      onExit();
+    }
+    try {
+      await tick();
+    } catch (err) {
+      if (verbose) console.error(`  ! tick error: ${err instanceof Error ? err.message : err}`);
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+}
+
+// src/watch-cli.ts
+var args = process.argv.slice(2);
+var opts = {
+  includeAssistant: args.includes("--assistant") || args.includes("-a"),
+  includeUser: !args.includes("--no-user"),
+  intervalMs: (() => {
+    const i = args.findIndex((a) => a === "--interval" || a === "-i");
+    if (i >= 0 && args[i + 1]) return Math.max(500, Number(args[i + 1]) || 3e3);
+    return 3e3;
+  })(),
+  verbose: !args.includes("--quiet") && !args.includes("-q"),
+  exitWithParent: args.includes("--exit-with-parent")
+};
+runWatcher(opts).catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});