open-think 0.1.0 → 0.1.2

package/README.md

@@ -1,72 +1,108 @@
 # think
 
-Local-first CLI for capturing notes, work logs, and ideas with P2P sync between machines.
+Local-first CLI that gives AI agents persistent, curated memory.
 
-## Setup
+## Install
 
-Requires **Node 20** (native SQLite extensions don't compile on Node 22+).
+Requires **Node 22.5+** (uses `node:sqlite`).
 
 ```bash
-git clone git@github.com:MicroMediaSites/think-cli.git
-cd think-cli
-nvm use 20
-npm install
-npm run build
-npm link
+npm install -g open-think
 ```
 
-After `npm link`, the `think` command is available globally.
-
-**Note:** The build pins the Node 20 binary path in the shebang, so `think` will always use Node 20 regardless of your active nvm version. If your Node 20 is at a different path than the machine that last ran `npm run build`, just rebuild:
+## Quick start
 
 ```bash
-nvm use 20 && npm run build
-```
+# Log work events
+think sync "shipped the auth fix"
+think sync "EEP prototype demoed to product team"
 
-## Data
+# List recent entries
+think list --week
 
-- **Database:** `~/.local/share/think/think.db`
-- **Config:** `~/.config/think/config.json` (auto-generated on first run)
+# AI-powered summary
+think summary
+think summary --last-week --raw   # raw entries, no AI
+```
 
-Data lives on disk, not in the repo. Use `think network sync` to replicate between machines.
+## Cortex — shared team memory
 
-## Usage
+Cortexes connect agents across a team via a shared git repo. Engrams (raw events) stay local. A curator agent evaluates them and appends curated memories to the repo.
 
 ```bash
-# Log entries
-think log "idea for caching layer"
-think log "standup — discussed deploy timeline" --category meeting
-think sync "shipped the auth fix"              # shorthand for --category sync
+# Set up (once)
+think cortex setup git@github.com:org/hivedb.git
+think cortex create engineering
 
-# List entries
-think list --week
-think list --last-week --category sync
-think list --tag architecture
+# Work normally — think sync logs engrams locally
+think sync "deployed auth service to staging"
+
+# Curate — evaluate engrams, append memories to the branch
+think curate              # full run
+think curate --dry-run    # preview without pushing
+
+# Read team memories
+think recall "auth"       # search memories + local engrams
+think memory              # show all memories from branch
+
+# Monitor curation quality
+think monitor             # what got promoted vs dropped
 
-# Weekly summary (uses Claude subscription via Agent SDK)
-think summary                    # AI-powered summary of current week
-think summary --last-week --raw  # raw entries, no AI
+# Pull another team's memories
+think pull product
+```
+
+### Privacy
 
-# P2P sync (both machines must be on the same LAN)
-think network sync               # discover peers via mDNS and sync
-think network sync --host 192.168.1.50  # sync with a specific machine
-think network status             # show known peers and last sync times
+```bash
+think pause    # suppress engram creation (silent no-op)
+think resume   # re-enable
 ```
 
-## Categories
+### Curator guidance
 
-- `note` (default) — general notes and ideas
-- `sync` — work log entries for 1:1 meetings
-- `meeting` — meeting notes
-- `decision` — decisions made
-- `idea` — ideas to revisit
+Each contributor can guide their curator with a personal prompt:
 
-## Syncing between machines
+```bash
+think curator edit    # opens ~/.think/curator.md in $EDITOR
+think curator show    # print current guidance
+```
 
-Both machines need `think` installed. When on the same network:
+## Data
+
+- **Engrams:** `~/.local/share/think/think.db` (no cortex) or `~/.think/engrams/<cortex>.db`
+- **Config:** `~/.config/think/config.json`
+- **Curator guidance:** `~/.think/curator.md`
+- **Memories:** `memories.jsonl` on cortex git branches (append-only JSONL)
 
-1. Run `think network sync` on either machine
-2. Peers discover each other automatically via mDNS/Bonjour
-3. Entries replicate in both directions using CRDTs (no conflicts)
+## All commands
 
-After syncing, `think summary --week` on either machine produces the same output.
+```
+think sync <message>           Log a work event
+think log <message>            Log a note (with --category, --tags)
+think list                     List entries (--week, --since, --category)
+think summary                  AI summary (--raw for plain text)
+think delete                   Soft-delete entries
+
+think cortex setup <repo>      Configure git repo for shared memory
+think cortex create <name>     Create a cortex branch
+think cortex list              Show cortex branches
+think cortex switch <name>     Set active cortex
+think cortex current           Show active cortex
+
+think curate                   Run curation (--dry-run to preview)
+think monitor                  Show promoted vs dropped engrams
+think recall <query>           Search memories + engrams
+think memory                   Show memories (--history for git log)
+think pull <cortex>            Pull another cortex's memories
+
+think curator edit             Edit personal curator guidance
+think curator show             Show current guidance
+think pause                    Suppress engram creation
+think resume                   Re-enable engram creation
+
+think init                     Set up CLAUDE.md for auto-logging
+think export                   Export entries as sync bundle
+think import <file>            Import sync bundle
+think audit                    Show sync audit log
+```

package/dist/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node --no-warnings=ExperimentalWarning
 
 // src/index.ts
-import { Command as Command16 } from "commander";
+import { Command as Command18 } from "commander";
 
 // src/commands/log.ts
 import { Command } from "commander";
+import { spawn } from "child_process";
 import chalk from "chalk";
 
 // src/db/queries.ts
@@ -346,6 +347,9 @@ var logCommand = new Command("log").description("Log a note or entry").argument(
 var syncCommand = new Command("sync").description("Log a sync/work-log entry (shorthand for log --category sync)").argument("<message>", "The message to log").option("-s, --source <source>", "Source of the entry", "manual").option("-t, --tags <tags>", "Comma-separated tags").option("--silent", "Suppress output").action(function(message, opts) {
   const globalOpts = this.optsWithGlobals();
   const config = getConfig();
+  if (config.paused) {
+    return;
+  }
   const cortex = globalOpts.cortex ?? config.cortex?.active;
   if (cortex) {
     const engram = insertEngram(cortex, { content: message });
@@ -355,6 +359,18 @@ var syncCommand = new Command("sync").description("Log a sync/work-log entry (sh
       console.log(`${chalk.green("\u2713")} ${badge} engram saved ${ts}`);
       console.log(`  ${engram.content}`);
     }
+    const curateEveryN = config.cortex?.curateEveryN;
+    if (curateEveryN && curateEveryN > 0) {
+      const pending = getPendingEngrams(cortex);
+      if (pending.length >= curateEveryN) {
+        if (!opts.silent) {
+          console.log(chalk.dim(`  ${pending.length} pending engrams \u2014 triggering curation...`));
+        }
+        closeEngramsDb(cortex);
+        spawn(process.execPath, [process.argv[1], "curate"], { detached: true, stdio: "ignore" }).unref();
+        return;
+      }
+    }
     closeEngramsDb(cortex);
   } else {
     const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()) : void 0;
@@ -1019,6 +1035,7 @@ cortexCommand.addCommand(new Command9("current").description("Show the active co
 
 // src/commands/curate.ts
 import { Command as Command10 } from "commander";
+import readline3 from "readline";
 import chalk10 from "chalk";
 
 // src/lib/curator.ts
@@ -1214,6 +1231,42 @@ var curateCommand = new Command10("curate").description("Run curation: evaluate
     closeEngramsDb(cortex);
     return;
   }
+  if (config.cortex?.confirmBeforeCommit && newEntries.length > 0) {
+    console.log();
+    console.log(chalk10.cyan("Proposed memories:"));
+    for (let i = 0; i < newEntries.length; i++) {
+      console.log(chalk10.green(`  ${i + 1}. `) + newEntries[i].content);
+    }
+    console.log();
+    const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question("  Commit these memories? [Y/n/edit] ", (ans) => {
+        rl.close();
+        resolve(ans.trim().toLowerCase());
+      });
+    });
+    if (answer === "n" || answer === "no") {
+      console.log(chalk10.dim("  Aborted. Engrams left as pending."));
+      closeEngramsDb(cortex);
+      return;
+    }
+    if (answer === "e" || answer === "edit") {
+      for (let i = 0; i < newEntries.length; i++) {
+        const editRl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+        const edited = await new Promise((resolve) => {
+          editRl.question(`  ${i + 1}. ${chalk10.dim("(enter to keep, or type replacement)")}
+     ${newEntries[i].content}
+     > `, (ans) => {
+            editRl.close();
+            resolve(ans.trim());
+          });
+        });
+        if (edited) {
+          newEntries[i].content = edited;
+        }
+      }
+    }
+  }
   if (newEntries.length > 0) {
     const newLines = newEntries.map((e) => JSON.stringify(e));
     const commitMsg = `curate: ${author}, ${pending.length} engrams, ${newEntries.length} memories`;
@@ -1444,8 +1497,64 @@ var pullCommand = new Command15("pull").argument("<cortex>", "Cortex branch to p
 ${recentMemories.length} memories`));
 });
 
+// src/commands/pause.ts
+import { Command as Command16 } from "commander";
+import chalk16 from "chalk";
+var pauseCommand = new Command16("pause").description("Pause engram creation \u2014 think sync will silently skip until resumed").action(() => {
+  const config = getConfig();
+  config.paused = true;
+  saveConfig(config);
+  console.log(chalk16.yellow("\u23F8") + " Engram creation paused. Run " + chalk16.dim("think resume") + " to re-enable.");
+});
+var resumeCommand = new Command16("resume").description("Resume engram creation after a pause").action(() => {
+  const config = getConfig();
+  config.paused = false;
+  saveConfig(config);
+  console.log(chalk16.green("\u2713") + " Engram creation resumed.");
+});
+
+// src/commands/config-cmd.ts
+import { Command as Command17 } from "commander";
+import chalk17 from "chalk";
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "cortex.curateEveryN",
+  "cortex.confirmBeforeCommit",
+  "cortex.author",
+  "cortex.repo",
+  "cortex.active",
+  "paused"
+]);
+var configCommand = new Command17("config").description("View or update think configuration");
+configCommand.addCommand(new Command17("show").description("Print current configuration").action(() => {
+  const config = getConfig();
+  console.log(JSON.stringify(config, null, 2));
+}));
+configCommand.addCommand(new Command17("set").argument("<key>", "Config key (e.g., cortex.curateEveryN, cortex.confirmBeforeCommit)").argument("<value>", "Value to set").description("Set a configuration value").action((key, value) => {
+  if (!ALLOWED_KEYS.has(key)) {
+    console.error(chalk17.red(`Unknown config key: ${key}`));
+    console.error(chalk17.dim(`Allowed keys: ${[...ALLOWED_KEYS].join(", ")}`));
+    process.exit(1);
+  }
+  const config = getConfig();
+  let parsed = value;
+  if (value === "true") parsed = true;
+  else if (value === "false") parsed = false;
+  else if (/^\d+$/.test(value)) parsed = parseInt(value, 10);
+  const parts = key.split(".");
+  let target = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!target[parts[i]] || typeof target[parts[i]] !== "object") {
+      target[parts[i]] = {};
+    }
+    target = target[parts[i]];
+  }
+  target[parts[parts.length - 1]] = parsed;
+  saveConfig(config);
+  console.log(chalk17.green("\u2713") + ` ${key} = ${JSON.stringify(parsed)}`);
+}));
+
 // src/index.ts
-var program = new Command16();
+var program = new Command18();
 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);
@@ -1463,4 +1572,7 @@ program.addCommand(recallCommand);
 program.addCommand(memoryCommand);
 program.addCommand(curatorCommand);
 program.addCommand(pullCommand);
+program.addCommand(pauseCommand);
+program.addCommand(resumeCommand);
+program.addCommand(configCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-think",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Local-first CLI that gives AI agents persistent, curated memory",
   "bin": {
@@ -28,6 +28,9 @@
     "curation"
   ],
   "license": "MIT",
+  "engines": {
+    "node": ">=22.5.0"
+  },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.98",
     "chalk": "^5.4.1",