open-think 0.2.1 → 0.2.3

package/dist/{chunk-K2FT7ZHJ.js → chunk-N4VAGRBF.js}

@@ -136,8 +136,8 @@ function createOrphanBranch(branchName) {
   } catch {
   }
   const repoPath = getRepoPath();
-  fs3.writeFileSync(path3.join(repoPath, "memories.jsonl"), "", "utf-8");
-  runGit(["add", "memories.jsonl"]);
+  fs3.writeFileSync(path3.join(repoPath, "000001.jsonl"), "", "utf-8");
+  runGit(["add", "000001.jsonl"]);
   runGit(["commit", "-m", `init: create cortex ${branchName}`]);
   runGit(["push", "--set-upstream", "origin", branchName]);
 }
@@ -151,9 +151,9 @@ function readFileFromBranch(branchName, filePath) {
     return null;
   }
 }
-function appendAndCommit(branchName, newLines, commitMessage, maxRetries = 3) {
+function appendAndCommit(branchName, newLines, commitMessage, maxRetries = 3, targetFile = "memories.jsonl") {
   const repoPath = getRepoPath();
-  const memoriesPath = path3.join(repoPath, "memories.jsonl");
+  const filePath = path3.join(repoPath, targetFile);
   try {
     runGit(["switch", branchName]);
   } catch {
@@ -168,12 +168,12 @@ function appendAndCommit(branchName, newLines, commitMessage, maxRetries = 3) {
         runGit(["rebase", "--abort"]);
       } catch {
       }
-      throw new Error(`Rebase conflict on ${branchName}. This should not happen with append-only files \u2014 check for manual edits to memories.jsonl.`);
+      throw new Error(`Rebase conflict on ${branchName}. This should not happen with append-only files.`);
     }
   }
   const content = newLines.join("\n") + "\n";
-  fs3.appendFileSync(memoriesPath, content, "utf-8");
-  runGit(["add", "memories.jsonl"]);
+  fs3.appendFileSync(filePath, content, "utf-8");
+  runGit(["add", targetFile]);
   runGit(["commit", "-m", commitMessage]);
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
@@ -194,6 +194,58 @@ function listRemoteBranches() {
   const output = runGit(["ls-remote", "--heads", "origin"]);
   return output.trim().split("\n").filter(Boolean).map((line) => line.split("	")[1]?.replace("refs/heads/", "")).filter(Boolean);
 }
+function listBranchFiles(branchName, extension) {
+  try {
+    const output = runGit(["ls-tree", "--name-only", `origin/${branchName}`]);
+    let files = output.split("\n").filter(Boolean);
+    if (extension) {
+      files = files.filter((f) => f.endsWith(extension));
+    }
+    return files.sort();
+  } catch {
+    return [];
+  }
+}
+function countBranchFileLines(branchName, filePath) {
+  const content = readFileFromBranch(branchName, filePath);
+  if (!content) return 0;
+  return content.trim().split("\n").filter(Boolean).length;
+}
+function migrateToBuckets(branchName) {
+  const repoPath = getRepoPath();
+  try {
+    runGit(["switch", branchName]);
+  } catch {
+    runGit(["switch", "-c", branchName, `origin/${branchName}`]);
+  }
+  try {
+    runGit(["pull", "--rebase", "origin", branchName]);
+  } catch {
+  }
+  const legacyPath = path3.join(repoPath, "memories.jsonl");
+  const bucketPath = path3.join(repoPath, "000001.jsonl");
+  if (fs3.existsSync(legacyPath) && !fs3.existsSync(bucketPath)) {
+    const preMigrationRef = runGit(["rev-parse", "HEAD"]);
+    fs3.renameSync(legacyPath, bucketPath);
+    runGit(["add", "-A"]);
+    runGit(["commit", "-m", "migrate: memories.jsonl -> 000001.jsonl"]);
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        runGit(["push", "origin", branchName]);
+        return;
+      } catch {
+        if (attempt === 3) {
+          try {
+            runGit(["reset", "--hard", preMigrationRef]);
+          } catch {
+          }
+          throw new Error("Migration push failed after 3 attempts \u2014 local commit rolled back");
+        }
+        runGit(["pull", "--rebase", "origin", branchName]);
+      }
+    }
+  }
+}
 
 export {
   getThinkDataDir,
@@ -212,5 +264,8 @@ export {
   readFileFromBranch,
   appendAndCommit,
   getFileLog,
-  listRemoteBranches
+  listRemoteBranches,
+  listBranchFiles,
+  countBranchFileLines,
+  migrateToBuckets
 };

package/dist/{git-Y3N244VA.js → git-R4CVMKV7.js}

@@ -2,20 +2,26 @@
 import {
   appendAndCommit,
   branchExists,
+  countBranchFileLines,
   createOrphanBranch,
   ensureRepoCloned,
   fetchBranch,
   getFileLog,
+  listBranchFiles,
   listRemoteBranches,
+  migrateToBuckets,
   readFileFromBranch
-} from "./chunk-K2FT7ZHJ.js";
+} from "./chunk-N4VAGRBF.js";
 export {
   appendAndCommit,
   branchExists,
+  countBranchFileLines,
   createOrphanBranch,
   ensureRepoCloned,
   fetchBranch,
   getFileLog,
+  listBranchFiles,
   listRemoteBranches,
+  migrateToBuckets,
   readFileFromBranch
 };

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node --no-warnings=ExperimentalWarning
 import {
   appendAndCommit,
+  countBranchFileLines,
   createOrphanBranch,
   ensureRepoCloned,
   ensureThinkDirs,
@@ -12,10 +13,12 @@ import {
   getEngramsDir,
   getLongtermPath,
   getThinkDataDir,
+  listBranchFiles,
   listRemoteBranches,
+  migrateToBuckets,
   readFileFromBranch,
   saveConfig
-} from "./chunk-K2FT7ZHJ.js";
+} from "./chunk-N4VAGRBF.js";
 
 // src/index.ts
 import fs11 from "fs";
@@ -1498,13 +1501,45 @@ var GitSyncAdapter = class {
     const config = getConfig();
     return !!config.cortex?.repo;
   }
+  ensureMigrated(cortex, branchFiles) {
+    const hasNumbered = branchFiles.some((f) => /^\d{6}\.jsonl$/.test(f));
+    if (!hasNumbered) {
+      const hasLegacy = readFileFromBranch(cortex, "memories.jsonl") !== null;
+      if (hasLegacy) {
+        migrateToBuckets(cortex);
+      }
+    }
+  }
+  determineBucketFile(cortex, branchFiles) {
+    const config = getConfig();
+    const bucketSize = config.cortex?.bucketSize ?? 500;
+    const numbered = branchFiles.filter((f) => /^\d{6}\.jsonl$/.test(f));
+    if (numbered.length === 0) return "000001.jsonl";
+    const latestFile = numbered[numbered.length - 1];
+    const lineCount = countBranchFileLines(cortex, latestFile);
+    if (lineCount >= bucketSize) {
+      const nextNum = parseInt(latestFile.replace(".jsonl", ""), 10) + 1;
+      return String(nextNum).padStart(6, "0") + ".jsonl";
+    }
+    return latestFile;
+  }
   async push(cortex) {
     const result = { pushed: 0, pulled: 0, errors: [] };
     ensureRepoCloned();
+    fetchBranch(cortex);
     const cursorStr = getSyncCursor(cortex, "git", "push");
     const lastVersion = cursorStr ? parseInt(cursorStr, 10) : 0;
+    const branchFiles = listBranchFiles(cortex, ".jsonl");
+    try {
+      this.ensureMigrated(cortex, branchFiles);
+    } catch (err) {
+      result.errors.push(`Migration failed: ${err instanceof Error ? err.message : String(err)}`);
+      return result;
+    }
+    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;
+    const targetFile = this.determineBucketFile(cortex, currentFiles);
     const newLines = newMemories.map((m) => JSON.stringify({
       ts: m.ts,
       author: m.author,
@@ -1518,7 +1553,7 @@ var GitSyncAdapter = class {
     const maxVersion = Math.max(...newMemories.map((m) => m.sync_version));
     setSyncCursor(cortex, "git", "push", String(maxVersion));
     try {
-      appendAndCommit(cortex, newLines, commitMsg);
+      appendAndCommit(cortex, newLines, commitMsg, 3, targetFile);
       result.pushed = newMemories.length;
     } catch (err) {
       setSyncCursor(cortex, "git", "push", String(lastVersion));
@@ -1526,16 +1561,7 @@ var GitSyncAdapter = class {
     }
     return result;
   }
-  async pull(cortex) {
-    const result = { pushed: 0, pulled: 0, errors: [] };
-    try {
-      ensureRepoCloned();
-      fetchBranch(cortex);
-    } catch (err) {
-      result.errors.push(err instanceof Error ? err.message : String(err));
-      return result;
-    }
-    const memoriesRaw = readFileFromBranch(cortex, "memories.jsonl") ?? "";
+  processMemories(cortex, memoriesRaw, result) {
     const memories = parseMemoriesJsonl(memoriesRaw);
     for (const m of memories) {
       const id = deterministicId(m.ts, m.author, m.content);
@@ -1553,6 +1579,55 @@ var GitSyncAdapter = class {
       });
       if (wasInserted) result.pulled++;
     }
+  }
+  async pull(cortex) {
+    const result = { pushed: 0, pulled: 0, errors: [] };
+    try {
+      ensureRepoCloned();
+      fetchBranch(cortex);
+    } catch (err) {
+      result.errors.push(err instanceof Error ? err.message : String(err));
+      return result;
+    }
+    const config = getConfig();
+    const onboardingDepth = config.cortex?.onboardingDepth ?? 1500;
+    const bucketSize = config.cortex?.bucketSize ?? 500;
+    const files = listBranchFiles(cortex, ".jsonl").filter((f) => /^\d{6}\.jsonl$/.test(f)).sort();
+    if (files.length === 0) {
+      const memoriesRaw = readFileFromBranch(cortex, "memories.jsonl") ?? "";
+      if (memoriesRaw) {
+        this.processMemories(cortex, memoriesRaw, result);
+      }
+      return result;
+    }
+    const pullCursor = getSyncCursor(cortex, "git", "pull_file");
+    let filesToRead;
+    if (!pullCursor) {
+      const numFiles = Math.ceil(onboardingDepth / bucketSize);
+      filesToRead = files.slice(-numFiles);
+    } else {
+      const cursorIndex = files.indexOf(pullCursor);
+      if (cursorIndex === -1) {
+        const numFiles = Math.ceil(onboardingDepth / bucketSize);
+        filesToRead = files.slice(-numFiles);
+      } else {
+        filesToRead = files.slice(cursorIndex);
+      }
+    }
+    let lastReadFile = null;
+    for (const file of filesToRead) {
+      const raw = readFileFromBranch(cortex, file);
+      if (raw === null) {
+        break;
+      }
+      lastReadFile = file;
+      if (raw.trim()) {
+        this.processMemories(cortex, raw, result);
+      }
+    }
+    if (lastReadFile) {
+      setSyncCursor(cortex, "git", "pull_file", lastReadFile);
+    }
     return result;
   }
   async sync(cortex) {
@@ -1623,7 +1698,7 @@ cortexCommand.addCommand(new Command9("setup").description("Configure a sync bac
     const adapter = getSyncAdapter();
     if (adapter) {
       try {
-        const { ensureRepoCloned: ensureRepoCloned2 } = await import("./git-Y3N244VA.js");
+        const { ensureRepoCloned: ensureRepoCloned2 } = await import("./git-R4CVMKV7.js");
         ensureRepoCloned2();
         console.log(chalk9.green("\u2713") + " Repo cloned");
       } catch (err) {
@@ -2172,7 +2247,52 @@ var recallCommand = new Command12("recall").argument("<query>", "What to recall"
 // src/commands/memory.ts
 import { Command as Command13 } from "commander";
 import chalk13 from "chalk";
-var memoryCommand = new Command13("memory").description("Show current memories from local store").option("--history", "Show recent memory timeline").action(async (opts) => {
+var addCommand = new Command13("add").description("Add a memory directly, bypassing curation").argument("<message>", "The memory content").option("--no-push", "Skip pushing to remote after adding").option("--silent", "Suppress output").action(async function(message, opts) {
+  const globalOpts = this.optsWithGlobals();
+  const config = getConfig();
+  const cortex = globalOpts.cortex ?? config.cortex?.active;
+  if (!cortex) {
+    console.error(chalk13.red("No active cortex. Run: think cortex switch <name>"));
+    process.exit(1);
+  }
+  const author = config.cortex?.author ?? "unknown";
+  const validated = validateEngramContent(message);
+  message = validated.content;
+  if (!opts.silent && validated.warnings.length > 0) {
+    for (const w of validated.warnings) {
+      console.log(chalk13.yellow(`  \u26A0 ${w}`));
+    }
+  }
+  const row = insertMemory(cortex, {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    author,
+    content: message,
+    source_ids: []
+  });
+  if (!opts.silent) {
+    const badge = chalk13.cyan(`[${cortex}]`);
+    const ts = chalk13.gray(row.ts.slice(0, 16).replace("T", " "));
+    console.log(`${chalk13.green("\u2713")} ${badge} memory added ${ts}`);
+    console.log(`  ${row.content}`);
+  }
+  if (opts.push) {
+    const adapter = getSyncAdapter();
+    if (adapter?.isAvailable()) {
+      try {
+        const result = await adapter.push(cortex);
+        if (!opts.silent && result.pushed > 0) {
+          console.log(chalk13.dim(`  Pushed ${result.pushed} memories to ${adapter.name}`));
+        }
+      } catch {
+        if (!opts.silent) {
+          console.log(chalk13.dim("  Push skipped (remote unavailable) \u2014 will push on next sync"));
+        }
+      }
+    }
+  }
+  closeCortexDb(cortex);
+});
+async function showMemories(opts) {
   const config = getConfig();
   const cortex = config.cortex?.active;
   if (!cortex) {
@@ -2200,7 +2320,11 @@ var memoryCommand = new Command13("memory").description("Show current memories f
   console.log(chalk13.dim(`
 ${memories.length} memories`));
   closeCortexDb(cortex);
+}
+var memoryCommand = new Command13("memory").description("Show current memories from local store").option("--history", "Show recent memory timeline").action(async (opts) => {
+  await showMemories(opts);
 });
+memoryCommand.addCommand(addCommand);
 
 // src/commands/curator-cmd.ts
 import { Command as Command14 } from "commander";

package/package.json

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