open-think 0.4.0 → 0.4.1

package/dist/index.js

@@ -39,8 +39,8 @@ import {
 } from "./chunk-HUBRLTY3.js";
 
 // src/index.ts
-import fs13 from "fs";
-import path7 from "path";
+import fs14 from "fs";
+import path8 from "path";
 import { Command as Command21 } from "commander";
 
 // src/commands/log.ts
@@ -1648,8 +1648,18 @@ var GitSyncAdapter = class {
   }
   async push(cortex) {
     const result = { pushed: 0, pulled: 0, errors: [] };
-    ensureRepoCloned();
-    fetchBranch(cortex);
+    try {
+      ensureRepoCloned();
+      fetchBranch(cortex);
+    } catch (err) {
+      result.errors.push(err instanceof Error ? err.message : String(err));
+      return result;
+    }
+    this.pushMemories(cortex, result);
+    this.pushLongTermEvents(cortex, result);
+    return result;
+  }
+  pushMemories(cortex, result) {
     const cursorStr = getSyncCursor(cortex, "git", "push");
     const lastVersion = cursorStr ? parseInt(cursorStr, 10) : 0;
     const branchFiles = listBranchFiles(cortex, ".jsonl");
@@ -1657,11 +1667,11 @@ var GitSyncAdapter = class {
       this.ensureMigrated(cortex, branchFiles);
     } catch (err) {
       result.errors.push(`Migration failed: ${err instanceof Error ? err.message : String(err)}`);
-      return result;
+      return;
     }
     const currentFiles = branchFiles.some((f) => /^\d{6}\.jsonl$/.test(f)) ? branchFiles : listBranchFiles(cortex, ".jsonl");
     const newMemories = getMemoriesBySyncVersion(cortex, lastVersion);
-    if (newMemories.length === 0) return result;
+    if (newMemories.length === 0) return;
     const targetFile = this.determineBucketFile(cortex, currentFiles);
     const newLines = newMemories.map((m) => {
       let decisions = [];
@@ -1687,12 +1697,10 @@ var GitSyncAdapter = class {
     try {
       appendAndCommit(cortex, newLines, commitMsg, 3, targetFile);
       setSyncCursor(cortex, "git", "push", String(maxVersion));
-      result.pushed = newMemories.length;
+      result.pushed += newMemories.length;
     } catch (err) {
       result.errors.push(err instanceof Error ? err.message : String(err));
     }
-    this.pushLongTermEvents(cortex, result);
-    return result;
   }
   pushLongTermEvents(cortex, result) {
     const cursorStr = getSyncCursor(cortex, "git", "push_lt");
@@ -1766,6 +1774,11 @@ var GitSyncAdapter = class {
       result.errors.push(err instanceof Error ? err.message : String(err));
       return result;
     }
+    this.pullMemories(cortex, result);
+    this.pullLongTermEvents(cortex, result);
+    return result;
+  }
+  pullMemories(cortex, result) {
     const config = getConfig();
     const onboardingDepth = config.cortex?.onboardingDepth ?? 1500;
     const bucketSize = config.cortex?.bucketSize ?? 500;
@@ -1775,7 +1788,7 @@ var GitSyncAdapter = class {
       if (memoriesRaw) {
         this.processMemories(cortex, memoriesRaw, result);
       }
-      return result;
+      return;
     }
     const pullCursor = getSyncCursor(cortex, "git", "pull_file");
     let filesToRead;
@@ -1805,8 +1818,6 @@ var GitSyncAdapter = class {
     if (lastReadFile) {
       setSyncCursor(cortex, "git", "pull_file", lastReadFile);
     }
-    this.pullLongTermEvents(cortex, result);
-    return result;
   }
   pullLongTermEvents(cortex, result) {
     const raw = readFileFromBranch(cortex, LONG_TERM_FILE);
@@ -3185,31 +3196,72 @@ configCommand.addCommand(new Command17("set").argument("<key>", "Config key (e.g
 }));
 
 // src/commands/update.ts
+import fs12 from "fs";
+import path7 from "path";
 import { Command as Command18 } from "commander";
 import { execFileSync as execFileSync2 } from "child_process";
 import chalk18 from "chalk";
+function getInstalledVersion2() {
+  try {
+    const npmRoot = execFileSync2("npm", ["root", "-g"], { encoding: "utf-8" }).trim();
+    const pkgPath = path7.join(npmRoot, "open-think", "package.json");
+    if (!fs12.existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function getLatestPublishedVersion() {
+  try {
+    const v = execFileSync2("npm", ["view", "open-think", "version"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
 var updateCommand = new Command18("update").description("Update think to the latest version").action(() => {
   console.log(chalk18.cyan("Checking for updates..."));
+  const before = getInstalledVersion2();
+  const latest = getLatestPublishedVersion();
+  if (before && latest && before === latest) {
+    console.log(chalk18.dim(`Already up to date (open-think@${before}).`));
+    return;
+  }
   try {
-    const result = execFileSync2("npm", ["install", "-g", "open-think@latest"], {
+    execFileSync2("npm", ["install", "-g", "--prefer-online", "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."));
     }
+    return;
+  }
+  const after = getInstalledVersion2();
+  if (after && latest && after === latest) {
+    console.log(chalk18.green("\u2713") + ` Updated to open-think@${after}`);
+  } else if (after && before && after !== before) {
+    console.log(chalk18.green("\u2713") + ` Updated to open-think@${after}${latest ? chalk18.dim(` (registry says latest is ${latest})`) : ""}`);
+  } else if (after && latest && after !== latest) {
+    console.error(chalk18.yellow("\u26A0") + ` npm reported success but installed version is ${after}, expected ${latest}.`);
+    console.error(chalk18.dim("  Try: npm cache clean --force && npm install -g open-think@latest"));
+  } else if (after) {
+    console.log(chalk18.dim(`Installed version: open-think@${after} (could not verify against registry).`));
+  } else {
+    console.error(chalk18.yellow("\u26A0") + " Could not locate the installed package to verify the update.");
   }
 });
 
 // src/commands/migrate-data.ts
 import { Command as Command19 } from "commander";
-import fs12 from "fs";
+import fs13 from "fs";
 import chalk19 from "chalk";
 var migrateDataCommand = new Command19("migrate-data").description("Import existing memories from git into local SQLite (one-time migration)").action(async () => {
   const config = getConfig();
@@ -3247,8 +3299,8 @@ var migrateDataCommand = new Command19("migrate-data").description("Import exist
     if (wasInserted) inserted++;
   }
   const ltPath = getLongtermPath(cortex);
-  if (fs12.existsSync(ltPath)) {
-    const ltContent = fs12.readFileSync(ltPath, "utf-8").trim();
+  if (fs13.existsSync(ltPath)) {
+    const ltContent = fs13.readFileSync(ltPath, "utf-8").trim();
     if (ltContent) {
       setLongtermSummary(cortex, ltContent);
       console.log(chalk19.green("  \u2713") + " Long-term summary migrated");
@@ -3627,8 +3679,8 @@ longTermCommand.addCommand(new Command20("record").description("Manually record
 // src/index.ts
 function readPackageVersion() {
   try {
-    const pkgPath = path7.join(import.meta.dirname, "..", "package.json");
-    return JSON.parse(fs13.readFileSync(pkgPath, "utf-8")).version ?? "0.0.0";
+    const pkgPath = path8.join(import.meta.dirname, "..", "package.json");
+    return JSON.parse(fs14.readFileSync(pkgPath, "utf-8")).version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }

package/package.json

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