memoir-cli 3.6.1 → 3.8.0

package/README.md

@@ -15,7 +15,7 @@
 npx memoir-cli
 ```
 
-One command. No install, no config, no API keys. Your AI now has persistent memory across sessions, tools, and machines. Works with Claude Code, Cursor, Windsurf, Gemini CLI, GitHub Copilot, and 8 more tools.
+One command. No install, no config, no API keys. Your AI now has persistent memory across sessions, tools, and machines. Works with Claude Code, Cursor, Windsurf, Gemini CLI, GitHub Copilot, and 6 more tools.
 
 ---
 
@@ -44,7 +44,7 @@ npx memoir-cli
 
 That's it. memoir detects your AI tools, configures MCP, and activates memory. No global install needed.
 
-Your AI gets 7 memory tools:
+Your AI gets 14 memory tools:
 
 | MCP Tool | What it does |
 |----------|-------------|
@@ -55,6 +55,13 @@ Your AI gets 7 memory tools:
 | `memoir_consolidate` | Analyze memories for duplicates, staleness, and bloat |
 | `memoir_status` | See which AI tools are detected |
 | `memoir_profiles` | Switch between work/personal |
+| `memoir_set_goal` | Set the current session goal (pinned into CLAUDE.md) |
+| `memoir_add_next` | Add a next action to the current session |
+| `memoir_complete_next` | Mark a next action as done |
+| `memoir_note` | Record a decision with its rationale |
+| `memoir_ask` | Capture an open question for later |
+| `memoir_session` | Show goals, next actions, decisions, and recent sessions |
+| `memoir_why` | Look up why a past decision was made |
 
 ## Why memoir
 
@@ -62,7 +69,7 @@ Your AI forgets everything between sessions. You re-explain your codebase, your
 
 memoir fixes this by giving your AI a shared memory layer that works across **every tool you use**. Tell Claude something once. Cursor knows it too. Sync AI memory between tools, back it up to the cloud, restore it on any machine. And when your memories pile up, `memoir consolidate` cleans house — finds duplicates, flags stale context, and optionally uses AI to merge and prune.
 
-**13 tools supported:** Claude Code, Cursor, Windsurf, Gemini CLI, GitHub Copilot, OpenAI Codex, ChatGPT, Aider, Zed, Cline, Continue.dev, Augment, Trae.
+**11 tools supported:** Claude Code, Cursor, Windsurf, Gemini CLI, GitHub Copilot, OpenAI Codex, ChatGPT, Aider, Zed, Cline, Continue.dev.
 
 ## Sync across machines
 

package/bin/memoir.js

@@ -22,6 +22,19 @@ import { projectsListCommand, projectsTodoCommand } from '../src/commands/projec
 import { upgradeCommand } from '../src/commands/upgrade.js';
 import { activateCommand, deactivateCommand } from '../src/commands/activate.js';
 import { consolidateCommand } from '../src/commands/consolidate.js';
+import {
+  goalCommand,
+  nextCommand,
+  doneCommand,
+  noteCommand,
+  askCommand,
+  sessionShowCommand,
+  sessionClearCommand,
+} from '../src/commands/session.js';
+import { autopushCommand } from '../src/commands/autopush.js';
+import { whyCommand } from '../src/commands/why.js';
+import { autoRefreshCommand } from '../src/commands/auto-refresh.js';
+import { hooksInstallCommand, hooksUninstallCommand, hooksStatusCommand } from '../src/commands/hooks.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -99,6 +112,7 @@ program
   .description('Back up your AI memory to the cloud')
   .option('--only <tools>', 'Only sync specific tools (comma-separated)')
   .option('-p, --profile <name>', 'Use a specific profile')
+  .option('--redact', 'Strip detected secrets from synced files before they are backed up')
   .action(async (options) => {
     try {
       await pushCommand(options);
@@ -153,6 +167,106 @@ program
     }
   });
 
+// ── Session continuity ──────────────────────────────────────────
+program
+  .command('goal <text...>')
+  .description('Set your current goal (pinned into CLAUDE.md, syncs across machines)')
+  .action(async (text) => {
+    try { await goalCommand(text.join(' ')); }
+    catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
+program
+  .command('next <text...>')
+  .description('Add a next action')
+  .action(async (text) => {
+    try { await nextCommand(text.join(' ')); }
+    catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
+program
+  .command('done <text...>')
+  .description('Mark a next action complete (substring match)')
+  .action(async (text) => {
+    try { await doneCommand(text.join(' ')); }
+    catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
+program
+  .command('note <text...>')
+  .description('Record a decision with rationale (--why) and rejected alternative (--rejected)')
+  .option('--why <rationale>', 'Why this decision was made')
+  .option('--rejected <alternative>', 'The alternative you considered and rejected')
+  .action(async (text, options) => {
+    try { await noteCommand(text.join(' '), options); }
+    catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
+program
+  .command('ask <text...>')
+  .description('Capture an open question for later')
+  .action(async (text) => {
+    try { await askCommand(text.join(' ')); }
+    catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
+program
+  .command('why [query...]')
+  .description('Look up decisions by keyword — returns what was decided + why + what was rejected')
+  .action(async (query) => {
+    try { await whyCommand((query || []).join(' ')); }
+    catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
+program
+  .command('session')
+  .description('Show the current session state')
+  .action(async () => {
+    try { await sessionShowCommand(); }
+    catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
+program
+  .command('session-clear')
+  .description('Clear the current session (history retained)')
+  .action(async () => {
+    try { await sessionClearCommand(); }
+    catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
+// ── Hooks + auto-sync (called by Claude Code hooks or the user) ─────
+program
+  .command('autopush')
+  .description('Debounced auto-push — called by the Claude Code Stop hook')
+  .option('--debounce <seconds>', 'Minimum seconds between auto-pushes', '30')
+  .option('-v, --verbose', 'Print debounce state')
+  .action(async (options) => {
+    try { await autopushCommand(options); }
+    catch (err) { if (options.verbose) console.error(chalk.red(err.message)); /* silent by default */ }
+  });
+
+program
+  .command('auto-refresh')
+  .description('Re-render the pinned session block — called by the SessionStart hook')
+  .option('-v, --verbose', 'Print what changed')
+  .action(async (options) => {
+    try { await autoRefreshCommand(options); }
+    catch (err) { if (options.verbose) console.error(chalk.red(err.message)); }
+  });
+
+program
+  .command('hooks')
+  .description('Manage Claude Code hooks (install | uninstall | status)')
+  .argument('[subcommand]', 'install, uninstall, or status', 'status')
+  .option('-y, --yes', 'Skip confirmation prompts')
+  .action(async (subcommand, options) => {
+    try {
+      if (subcommand === 'install') await hooksInstallCommand(options);
+      else if (subcommand === 'uninstall') await hooksUninstallCommand(options);
+      else await hooksStatusCommand();
+    } catch (err) { console.error(chalk.red('\n✖ Error:'), err.message); process.exit(1); }
+  });
+
 program
   .command('doctor')
   .alias('diagnose')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "3.6.1",
+  "version": "3.8.0",
   "mcpName": "io.github.camgitt/memoir",
   "description": "MCP server that gives Claude, Cursor, and Gemini long-term memory across sessions. Your AI remembers your codebase, decisions, and preferences — across tools and machines.",
   "main": "src/index.js",
@@ -9,9 +9,18 @@
     "memoir": "bin/memoir.js",
     "memoir-mcp": "src/mcp.js"
   },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/camgitt/memoir.git"
+    "url": "git+https://github.com/camgitt/memoir.git"
   },
   "homepage": "https://memoir.sh",
   "bugs": {
@@ -19,8 +28,9 @@
   },
   "scripts": {
     "start": "node bin/memoir.js",
-    "test": "node test-cross-machine.mjs && bash test-cross-machine-e2e.sh",
+    "test": "node run-tests.mjs",
     "test:legacy": "bash test-local.sh",
+    "prepublishOnly": "npm test",
     "postinstall": "node -e \"try{const c='\\x1b[36m',r='\\x1b[0m',g='\\x1b[90m';console.log('\\n  '+c+'memoir'+r+' installed.\\n  Run '+c+'memoir activate'+r+' in any project to give your AI long-term memory.\\n  '+g+'https://memoir.sh'+r+'\\n')}catch{}\""
   },
   "keywords": [

package/src/commands/auto-refresh.js

@@ -0,0 +1,31 @@
+// Auto-refresh — called by the Claude Code SessionStart hook.
+// Reads current session.json (local) and re-injects the pinned block into
+// CLAUDE.md. Instant, no network, no side effects beyond that file.
+//
+// For cross-machine pull-on-start, that's a separate concern — handled by
+// periodic auto-restore or explicit `memoir restore`. This hook only ensures
+// the pinned block matches the current local session state.
+
+import { readSession } from '../session/state.js';
+import { renderSession } from '../session/render.js';
+import { injectInto, detectAvailableTargets } from '../session/inject.js';
+
+export async function autoRefreshCommand(options = {}) {
+  const verbose = !!options.verbose;
+  try {
+    const state = await readSession();
+    const rendered = renderSession(state);
+    const targets = detectAvailableTargets();
+    for (const [tool, target] of Object.entries(targets)) {
+      try {
+        const res = await injectInto(target, rendered);
+        if (verbose) console.log(`memoir auto-refresh: ${res.replaced ? 'updated' : 'created'} ${tool} → ${res.path}`);
+      } catch (err) {
+        if (verbose) console.error(`memoir auto-refresh: ${tool} failed: ${err.message}`);
+      }
+    }
+  } catch (err) {
+    if (verbose) console.error(`memoir auto-refresh: ${err.message}`);
+    // Never fail the hook — session start must proceed.
+  }
+}

package/src/commands/autopush.js

@@ -0,0 +1,57 @@
+// Auto-push command — called by the Claude Code Stop hook after every response.
+//
+// Rules of engagement:
+//   - Debounced: won't run more than once per DEBOUNCE_SECONDS.
+//   - Non-blocking: detaches a background subprocess and exits immediately
+//     so Claude's response pipeline is never held up.
+//   - Silent: no stdout unless --verbose is passed.
+//
+// The actual push work happens in a fully detached child — the hook process
+// itself just records a timestamp and returns.
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+
+const home = os.homedir();
+const STAMP_FILE = path.join(home, '.config', 'memoir', 'last-autopush.timestamp');
+const DEBOUNCE_SECONDS_DEFAULT = 30;
+
+export async function autopushCommand(options = {}) {
+  const debounce = parseInt(options.debounce || DEBOUNCE_SECONDS_DEFAULT, 10);
+  const verbose = !!options.verbose;
+
+  try {
+    await fs.ensureDir(path.dirname(STAMP_FILE));
+  } catch {}
+
+  const now = Date.now();
+  let last = 0;
+  try {
+    const raw = await fs.readFile(STAMP_FILE, 'utf8');
+    last = parseInt(raw.trim(), 10) || 0;
+  } catch {}
+
+  const elapsed = (now - last) / 1000;
+  if (last && elapsed < debounce) {
+    if (verbose) console.log(`memoir autopush: skipped (${Math.floor(elapsed)}s since last, debounce=${debounce}s)`);
+    return;
+  }
+
+  // Stamp BEFORE spawning so rapid repeat calls don't all race through.
+  try {
+    await fs.writeFile(STAMP_FILE, String(now));
+  } catch {}
+
+  // Detach a background push. Parent exits immediately so Claude isn't blocked.
+  const memoirBin = process.argv[1]; // path to this same memoir CLI
+  const child = spawn(process.execPath, [memoirBin, 'push'], {
+    detached: true,
+    stdio: verbose ? 'inherit' : 'ignore',
+    env: { ...process.env, MEMOIR_AUTOPUSH: '1' },
+  });
+  child.unref();
+
+  if (verbose) console.log('memoir autopush: triggered (background)');
+}

package/src/commands/doctor.js

@@ -8,15 +8,7 @@ import os from 'os';
 import { execSync } from 'child_process';
 import { getConfig } from '../config.js';
 import { adapters } from '../adapters/index.js';
-
-const SECRET_PATTERNS = [
-  { pattern: /sk-[a-zA-Z0-9]{20,}/, label: 'OpenAI/Stripe secret key' },
-  { pattern: /key-[a-zA-Z0-9]{20,}/, label: 'API key' },
-  { pattern: /ghp_[a-zA-Z0-9]{36,}/, label: 'GitHub personal access token' },
-  { pattern: /gho_[a-zA-Z0-9]{36,}/, label: 'GitHub OAuth token' },
-  { pattern: /AKIA[0-9A-Z]{16}/, label: 'AWS access key' },
-  { pattern: /Bearer\s+[a-zA-Z0-9._\-]{20,}/, label: 'Bearer token' },
-];
+import { scanForSecrets as scanTextForSecrets } from '../security/scanner.js';
 
 const SENSITIVE_FILENAMES = ['.env', 'credentials', 'token.json'];
 
@@ -61,11 +53,9 @@ async function scanForSecrets(files) {
       // Skip files larger than 1MB
       if (stat.size > 1024 * 1024) continue;
       const content = await fs.readFile(filePath, 'utf-8');
-      for (const { pattern, label } of SECRET_PATTERNS) {
-        if (pattern.test(content)) {
-          warnings.push({ file: filePath, reason: label });
-          break;
-        }
+      const { found } = scanTextForSecrets(content);
+      if (found.length > 0) {
+        warnings.push({ file: filePath, reason: found[0].label });
       }
     } catch {
       // Skip unreadable files

package/src/commands/hooks.js

@@ -0,0 +1,171 @@
+// Install / uninstall / status for Claude Code hooks.
+//
+// Hooks are configured in ~/.claude/settings.json under the `hooks` object:
+//   {
+//     "hooks": {
+//       "Stop":         [{ "matcher": "", "hooks": [{ "type": "command", "command": "..." }] }],
+//       "SessionStart": [{ "matcher": "", "hooks": [{ "type": "command", "command": "..." }] }]
+//     }
+//   }
+//
+// We merge into any existing hooks the user has — never clobber. Our entries
+// are identified by a marker in the command string so we can find and remove
+// them on uninstall.
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import inquirer from 'inquirer';
+
+const home = os.homedir();
+const CLAUDE_SETTINGS = path.join(home, '.claude', 'settings.json');
+const MARKER = 'memoir'; // any command containing this is ours
+
+const OUR_HOOKS = {
+  Stop: {
+    type: 'command',
+    command: 'memoir autopush --debounce 30',
+  },
+  SessionStart: {
+    type: 'command',
+    command: 'memoir auto-refresh',
+  },
+};
+
+async function readSettings() {
+  if (!await fs.pathExists(CLAUDE_SETTINGS)) return {};
+  try {
+    return JSON.parse(await fs.readFile(CLAUDE_SETTINGS, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+async function writeSettings(settings) {
+  await fs.ensureDir(path.dirname(CLAUDE_SETTINGS));
+  const tmp = `${CLAUDE_SETTINGS}.tmp-${process.pid}`;
+  await fs.writeFile(tmp, JSON.stringify(settings, null, 2));
+  await fs.move(tmp, CLAUDE_SETTINGS, { overwrite: true });
+}
+
+function findOurEntry(hookList) {
+  // hookList is array of { matcher, hooks: [{type, command}] }
+  return (hookList || []).findIndex(entry =>
+    (entry.hooks || []).some(h => h.type === 'command' && (h.command || '').includes(MARKER))
+  );
+}
+
+function ensureOurHook(settings, eventName, hook) {
+  settings.hooks = settings.hooks || {};
+  settings.hooks[eventName] = settings.hooks[eventName] || [];
+  const list = settings.hooks[eventName];
+
+  const existing = findOurEntry(list);
+  if (existing >= 0) {
+    // Replace (idempotent — same shape every time)
+    list[existing] = { matcher: '', hooks: [hook] };
+  } else {
+    list.push({ matcher: '', hooks: [hook] });
+  }
+}
+
+function removeOurHook(settings, eventName) {
+  if (!settings?.hooks?.[eventName]) return false;
+  const list = settings.hooks[eventName];
+  const idx = findOurEntry(list);
+  if (idx < 0) return false;
+  list.splice(idx, 1);
+  if (list.length === 0) delete settings.hooks[eventName];
+  return true;
+}
+
+export async function hooksInstallCommand(options = {}) {
+  const settings = await readSettings();
+  const fresh = JSON.parse(JSON.stringify(settings)); // snapshot for diff
+
+  ensureOurHook(fresh, 'Stop', OUR_HOOKS.Stop);
+  ensureOurHook(fresh, 'SessionStart', OUR_HOOKS.SessionStart);
+
+  const isNoop = JSON.stringify(settings) === JSON.stringify(fresh);
+  if (isNoop) {
+    console.log('\n' + chalk.green('  ✓ Hooks already installed — nothing to do.\n'));
+    return;
+  }
+
+  // Show what will change
+  console.log('\n' + boxen(
+    chalk.cyan('memoir will add these hooks to ') + chalk.white.bold('~/.claude/settings.json') + chalk.cyan(':') + '\n\n' +
+    chalk.gray('  Stop:         ') + chalk.white(OUR_HOOKS.Stop.command) + '\n' +
+    chalk.gray('                fires after every response; auto-pushes (debounced 30s)') + '\n\n' +
+    chalk.gray('  SessionStart: ') + chalk.white(OUR_HOOKS.SessionStart.command) + '\n' +
+    chalk.gray('                fires at session open; refreshes pinned block from session.json') + '\n\n' +
+    chalk.gray('  Your existing settings (including other hooks) will be preserved.'),
+    { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ) + '\n');
+
+  if (!options.yes) {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Install hooks?',
+      default: true,
+    }]);
+    if (!confirm) {
+      console.log(chalk.yellow('\n  Cancelled.\n'));
+      return;
+    }
+  }
+
+  await writeSettings(fresh);
+  console.log('\n' + chalk.green('  ✓ Hooks installed. Restart Claude Code to activate.\n'));
+}
+
+export async function hooksUninstallCommand(options = {}) {
+  const settings = await readSettings();
+  const fresh = JSON.parse(JSON.stringify(settings));
+  const removedStop = removeOurHook(fresh, 'Stop');
+  const removedStart = removeOurHook(fresh, 'SessionStart');
+
+  if (!removedStop && !removedStart) {
+    console.log('\n' + chalk.gray('  No memoir hooks installed.\n'));
+    return;
+  }
+
+  if (!options.yes) {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Remove memoir hooks from ~/.claude/settings.json?',
+      default: true,
+    }]);
+    if (!confirm) {
+      console.log(chalk.yellow('\n  Cancelled.\n'));
+      return;
+    }
+  }
+
+  await writeSettings(fresh);
+  console.log('\n' + chalk.green('  ✓ memoir hooks removed.\n'));
+}
+
+export async function hooksStatusCommand() {
+  const settings = await readSettings();
+  const hasStop = (settings.hooks?.Stop || []).some(entry =>
+    (entry.hooks || []).some(h => (h.command || '').includes(MARKER))
+  );
+  const hasStart = (settings.hooks?.SessionStart || []).some(entry =>
+    (entry.hooks || []).some(h => (h.command || '').includes(MARKER))
+  );
+
+  const mark = (b) => b ? chalk.green('  ✓ ') : chalk.gray('  ✗ ');
+  console.log('\n' + boxen(
+    chalk.cyan.bold('memoir hooks status') + '\n\n' +
+    mark(hasStop) + chalk.white('Stop hook') + chalk.gray(' (auto-push)') + '\n' +
+    mark(hasStart) + chalk.white('SessionStart hook') + chalk.gray(' (auto-refresh)') + '\n\n' +
+    chalk.gray('  Settings: ') + chalk.white(CLAUDE_SETTINGS) + '\n' +
+    chalk.gray('  Run ') + chalk.cyan('memoir hooks install') + chalk.gray(' to add missing hooks.'),
+    { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
+  ) + '\n');
+}