open-think 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node --no-warnings=ExperimentalWarning
 
 // src/index.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 
 // src/commands/log.ts
 import { Command } from "commander";
@@ -324,6 +324,70 @@ function searchEngrams(cortexName, query3, limit = 20) {
   }
 }
 
+// src/lib/update-check.ts
+import fs4 from "fs";
+import path4 from "path";
+import { execFile } from "child_process";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var PACKAGE_NAME = "open-think";
+function cachePath() {
+  return path4.join(getConfigDir(), "version-cache.json");
+}
+function readCache() {
+  try {
+    const raw = fs4.readFileSync(cachePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  const dir = getConfigDir();
+  fs4.mkdirSync(dir, { recursive: true });
+  fs4.writeFileSync(cachePath(), JSON.stringify(cache), "utf-8");
+}
+function getInstalledVersion() {
+  try {
+    const pkgPath = path4.join(import.meta.dirname, "..", "package.json");
+    const raw = fs4.readFileSync(pkgPath, "utf-8");
+    return JSON.parse(raw).version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+  }
+  return false;
+}
+function checkForUpdate() {
+  const installed = getInstalledVersion();
+  if (!installed) return null;
+  const cache = readCache();
+  const now = Date.now();
+  if (cache && now - cache.checkedAt < CHECK_INTERVAL_MS) {
+    if (isNewer(cache.latest, installed)) {
+      return `open-think ${cache.latest} available (you have ${installed}). Run: npm update -g open-think`;
+    }
+    return null;
+  }
+  execFile("npm", ["view", PACKAGE_NAME, "version"], { timeout: 5e3 }, (err, stdout) => {
+    if (err) return;
+    const latest = stdout.trim();
+    if (latest) {
+      writeCache({ latest, checkedAt: Date.now() });
+    }
+  });
+  if (cache && isNewer(cache.latest, installed)) {
+    return `open-think ${cache.latest} available (you have ${installed}). Run: npm update -g open-think`;
+  }
+  return null;
+}
+
 // src/commands/log.ts
 var logCommand = new Command("log").description("Log a note or entry").argument("<message>", "The message to log").option("-s, --source <source>", "Source of the entry", "manual").option("-c, --category <category>", "Category: note, sync, meeting, decision, idea", "note").option("-t, --tags <tags>", "Comma-separated tags").option("--silent", "Suppress output").action((message, opts) => {
   const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()) : void 0;
@@ -391,6 +455,12 @@ var syncCommand = new Command("sync").description("Log a sync/work-log entry (sh
     }
     closeDb();
   }
+  if (!opts.silent) {
+    const updateMsg = checkForUpdate();
+    if (updateMsg) {
+      console.log(chalk.yellow(`  \u2139 ${updateMsg}`));
+    }
+  }
 });
 
 // src/commands/list.ts
@@ -574,7 +644,7 @@ var deleteCommand = new Command4("delete").description("Soft-delete entries (tom
 
 // src/commands/export.ts
 import { Command as Command5 } from "commander";
-import fs4 from "fs";
+import fs5 from "fs";
 import chalk5 from "chalk";
 var exportCommand = new Command5("export").description("Export entries as a sync bundle (file-based sync)").option("-o, --output <file>", "Write to file instead of stdout").option("--since <date>", "Export entries since date (ISO or YYYY-MM-DD)").option("-n, --limit <n>", "Max entries to export (default: all)").action((opts) => {
   const config = getConfig();
@@ -598,7 +668,7 @@ var exportCommand = new Command5("export").description("Export entries as a sync
   };
   const json = JSON.stringify(bundle, null, 2);
   if (opts.output) {
-    fs4.writeFileSync(opts.output, json, "utf-8");
+    fs5.writeFileSync(opts.output, json, "utf-8");
     console.log(chalk5.green("\u2713") + ` Exported ${entries.length} entries to ${opts.output}`);
     if (opts.since) {
       console.log(chalk5.dim(`  since: ${opts.since}`));
@@ -611,36 +681,36 @@ var exportCommand = new Command5("export").description("Export entries as a sync
 
 // src/commands/import.ts
 import { Command as Command6 } from "commander";
-import fs6 from "fs";
+import fs7 from "fs";
 import chalk6 from "chalk";
 
 // src/lib/audit.ts
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 function auditLogPath() {
-  return path4.join(getDataDir(), "sync-audit.log");
+  return path5.join(getDataDir(), "sync-audit.log");
 }
 function logAudit(entry) {
   const line = JSON.stringify(entry) + "\n";
-  fs5.appendFileSync(auditLogPath(), line, "utf-8");
+  fs6.appendFileSync(auditLogPath(), line, "utf-8");
 }
 function readAuditLog() {
   const logPath = auditLogPath();
-  if (!fs5.existsSync(logPath)) return [];
-  const lines = fs5.readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
+  if (!fs6.existsSync(logPath)) return [];
+  const lines = fs6.readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 
 // src/commands/import.ts
 var importCommand = new Command6("import").description("Import a sync bundle from another device").argument("<file>", "Path to the sync bundle JSON file").action((file) => {
-  if (!fs6.existsSync(file)) {
+  if (!fs7.existsSync(file)) {
     console.error(chalk6.red(`File not found: ${file}`));
     closeDb();
     process.exit(1);
   }
   let bundle;
   try {
-    const raw = fs6.readFileSync(file, "utf-8");
+    const raw = fs7.readFileSync(file, "utf-8");
     bundle = JSON.parse(raw);
   } catch {
     console.error(chalk6.red("Failed to parse sync bundle \u2014 is this a valid JSON file?"));
@@ -714,8 +784,8 @@ var importCommand = new Command6("import").description("Import a sync bundle fro
 
 // src/commands/init.ts
 import { Command as Command7 } from "commander";
-import fs7 from "fs";
-import path5 from "path";
+import fs8 from "fs";
+import path6 from "path";
 import readline from "readline";
 import chalk7 from "chalk";
 var CLAUDE_MD_SECTION = `# Work Logging
@@ -751,7 +821,7 @@ var initCommand = new Command7("init").description("Set up Claude Code integrati
   const defaultDir = home;
   let targetDir;
   if (opts.dir) {
-    targetDir = path5.resolve(opts.dir);
+    targetDir = path6.resolve(opts.dir);
   } else if (opts.yes) {
     targetDir = defaultDir;
   } else {
@@ -760,25 +830,25 @@ var initCommand = new Command7("init").description("Set up Claude Code integrati
       defaultDir
     );
     targetDir = targetDir.replace(/^~/, home);
-    targetDir = path5.resolve(targetDir);
+    targetDir = path6.resolve(targetDir);
   }
-  if (!fs7.existsSync(targetDir)) {
+  if (!fs8.existsSync(targetDir)) {
     console.error(chalk7.red(`Directory does not exist: ${targetDir}`));
     process.exit(1);
   }
-  const filePath = path5.join(targetDir, "CLAUDE.md");
-  const exists = fs7.existsSync(filePath);
+  const filePath = path6.join(targetDir, "CLAUDE.md");
+  const exists = fs8.existsSync(filePath);
   if (exists) {
-    const existing = fs7.readFileSync(filePath, "utf-8");
+    const existing = fs8.readFileSync(filePath, "utf-8");
     if (existing.includes("think sync")) {
       console.log(chalk7.dim("CLAUDE.md already contains think sync instructions. Nothing to do."));
       return;
     }
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    fs7.writeFileSync(filePath, existing + separator + CLAUDE_MD_SECTION, "utf-8");
+    fs8.writeFileSync(filePath, existing + separator + CLAUDE_MD_SECTION, "utf-8");
     console.log(chalk7.green("\u2713") + ` Appended work logging instructions to ${filePath}`);
   } else {
-    fs7.writeFileSync(filePath, CLAUDE_MD_SECTION, "utf-8");
+    fs8.writeFileSync(filePath, CLAUDE_MD_SECTION, "utf-8");
     console.log(chalk7.green("\u2713") + ` Created ${filePath} with work logging instructions`);
   }
   console.log(chalk7.dim("  Claude Code sessions under this directory will now auto-log with think sync."));
@@ -829,8 +899,8 @@ import readline2 from "readline";
 
 // src/lib/git.ts
 import { execFileSync } from "child_process";
-import fs8 from "fs";
-import path6 from "path";
+import fs9 from "fs";
+import path7 from "path";
 function runGit(args, cwd) {
   const repoPath = cwd ?? getRepoPath();
   return execFileSync("git", args, {
@@ -845,14 +915,14 @@ function ensureRepoCloned() {
     throw new Error("No cortex repo configured. Run: think cortex setup");
   }
   const repoPath = getRepoPath();
-  if (fs8.existsSync(path6.join(repoPath, ".git"))) {
+  if (fs9.existsSync(path7.join(repoPath, ".git"))) {
     const remote = runGit(["remote", "get-url", "origin"], repoPath);
     if (remote !== config.cortex.repo) {
       throw new Error(`Repo at ${repoPath} points to ${remote}, expected ${config.cortex.repo}`);
     }
     return;
   }
-  fs8.mkdirSync(repoPath, { recursive: true });
+  fs9.mkdirSync(repoPath, { recursive: true });
   execFileSync("git", ["clone", "--no-checkout", config.cortex.repo, repoPath], {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -873,7 +943,7 @@ function createOrphanBranch(branchName) {
   } catch {
   }
   const repoPath = getRepoPath();
-  fs8.writeFileSync(path6.join(repoPath, "memories.jsonl"), "", "utf-8");
+  fs9.writeFileSync(path7.join(repoPath, "memories.jsonl"), "", "utf-8");
   runGit(["add", "memories.jsonl"]);
   runGit(["commit", "-m", `init: create cortex ${branchName}`]);
   runGit(["push", "--set-upstream", "origin", branchName]);
@@ -890,7 +960,7 @@ function readFileFromBranch(branchName, filePath) {
 }
 function appendAndCommit(branchName, newLines, commitMessage, maxRetries = 3) {
   const repoPath = getRepoPath();
-  const memoriesPath = path6.join(repoPath, "memories.jsonl");
+  const memoriesPath = path7.join(repoPath, "memories.jsonl");
   try {
     runGit(["switch", branchName]);
   } catch {
@@ -909,7 +979,7 @@ function appendAndCommit(branchName, newLines, commitMessage, maxRetries = 3) {
     }
   }
   const content = newLines.join("\n") + "\n";
-  fs8.appendFileSync(memoriesPath, content, "utf-8");
+  fs9.appendFileSync(memoriesPath, content, "utf-8");
   runGit(["add", "memories.jsonl"]);
   runGit(["commit", "-m", commitMessage]);
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -1039,7 +1109,7 @@ import readline3 from "readline";
 import chalk10 from "chalk";
 
 // src/lib/curator.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 var BASE_CURATION_PROMPT = `You are a memory curator. You evaluate recent work events and decide which ones are significant enough to become shared team memory.
 
@@ -1090,8 +1160,8 @@ Rules:
 - Only add an entry if there is genuinely new information`;
 function readCuratorMd() {
   const mdPath = getCuratorMdPath();
-  if (fs9.existsSync(mdPath)) {
-    return fs9.readFileSync(mdPath, "utf-8").trim();
+  if (fs10.existsSync(mdPath)) {
+    return fs10.readFileSync(mdPath, "utf-8").trim();
   }
   return null;
 }
@@ -1339,7 +1409,7 @@ var monitorCommand = new Command11("monitor").description("Show what got promote
 // src/commands/recall.ts
 import { Command as Command12 } from "commander";
 import chalk12 from "chalk";
-import fs10 from "fs";
+import fs11 from "fs";
 var recallCommand = new Command12("recall").argument("<query>", "What to recall").description("Search memories from the cortex branch + local engrams").option("--days <n>", "Days of memories to include", "14").action(async (query3, opts) => {
   const config = getConfig();
   const cortex = config.cortex?.active;
@@ -1356,7 +1426,7 @@ var recallCommand = new Command12("recall").argument("<query>", "What to recall"
   const recentMemories = allMemories.filter((m) => m.ts >= cutoff);
   const matchingEngrams = searchEngrams(cortex, query3);
   const ltPath = getLongtermPath(cortex);
-  const longterm = fs10.existsSync(ltPath) ? fs10.readFileSync(ltPath, "utf-8").trim() : null;
+  const longterm = fs11.existsSync(ltPath) ? fs11.readFileSync(ltPath, "utf-8").trim() : null;
   if (recentMemories.length > 0) {
     console.log(chalk12.cyan(`Team memories (last ${days} days):`));
     for (const m of recentMemories) {
@@ -1425,7 +1495,7 @@ ${memories.length} memories`));
 // src/commands/curator-cmd.ts
 import { Command as Command14 } from "commander";
 import { spawnSync } from "child_process";
-import fs11 from "fs";
+import fs12 from "fs";
 import chalk14 from "chalk";
 var CURATOR_TEMPLATE = `# Curator Guidance
 
@@ -1444,8 +1514,8 @@ var curatorCommand = new Command14("curator").description("Manage personal curat
 curatorCommand.addCommand(new Command14("edit").description("Edit your curator guidance in $EDITOR").action(() => {
   ensureThinkDirs();
   const mdPath = getCuratorMdPath();
-  if (!fs11.existsSync(mdPath)) {
-    fs11.writeFileSync(mdPath, CURATOR_TEMPLATE, "utf-8");
+  if (!fs12.existsSync(mdPath)) {
+    fs12.writeFileSync(mdPath, CURATOR_TEMPLATE, "utf-8");
   }
   const editor = process.env.EDITOR || "vi";
   const result = spawnSync(editor, [mdPath], { stdio: "inherit" });
@@ -1457,8 +1527,8 @@ curatorCommand.addCommand(new Command14("edit").description("Edit your curator g
 }));
 curatorCommand.addCommand(new Command14("show").description("Print your current curator guidance").action(() => {
   const mdPath = getCuratorMdPath();
-  if (fs11.existsSync(mdPath)) {
-    console.log(fs11.readFileSync(mdPath, "utf-8"));
+  if (fs12.existsSync(mdPath)) {
+    console.log(fs12.readFileSync(mdPath, "utf-8"));
   } else {
     console.log(chalk14.dim("No curator guidance configured. Run: think curator edit"));
   }
@@ -1553,8 +1623,31 @@ configCommand.addCommand(new Command17("set").argument("<key>", "Config key (e.g
   console.log(chalk17.green("\u2713") + ` ${key} = ${JSON.stringify(parsed)}`);
 }));
 
+// src/commands/update.ts
+import { Command as Command18 } from "commander";
+import { execFileSync as execFileSync2 } from "child_process";
+import chalk18 from "chalk";
+var updateCommand = new Command18("update").description("Update think to the latest version").action(() => {
+  console.log(chalk18.cyan("Checking for updates..."));
+  try {
+    const result = execFileSync2("npm", ["install", "-g", "open-think@latest"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const match = result.match(/open-think@(\S+)/);
+    const version = match ? match[1] : "latest";
+    console.log(chalk18.green("\u2713") + ` Updated to open-think@${version}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk18.red("Update failed. Try manually: npm install -g open-think@latest"));
+    if (message.includes("EACCES")) {
+      console.error(chalk18.dim("  You may need to run with sudo or fix npm permissions."));
+    }
+  }
+});
+
 // src/index.ts
-var program = new Command18();
+var program = new Command19();
 program.name("think").description("Local-first CLI tool for capturing notes, work logs, and ideas").version("0.1.0").option("-C, --cortex <name>", "Use a specific cortex for this command");
 program.addCommand(logCommand);
 program.addCommand(syncCommand);
@@ -1575,4 +1668,5 @@ program.addCommand(pullCommand);
 program.addCommand(pauseCommand);
 program.addCommand(resumeCommand);
 program.addCommand(configCommand);
+program.addCommand(updateCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-think",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "description": "Local-first CLI that gives AI agents persistent, curated memory",
   "bin": {