mcvay-mind 1.1.0 → 1.1.1

package/index.js

@@ -18,6 +18,7 @@
  *   node index.js embed-rebuild [--types preference,lesson] [--batch-size 16]
  *   node index.js detect-preferences --from <file>
  *   node index.js feedback-preference --label <correct|missed|wrong> --utterance "..." --expected "..."
+ *   node index.js auto-capture status|enable|disable
  */
 
 const store = require('./lib/store');
@@ -31,6 +32,7 @@ const expandCache = require('./lib/expand-cache');
 const metrics = require('./lib/metrics');
 const { extractPreferences } = require('./lib/preference-extractor/Rule');
 const preferenceState = require('./lib/preference-state');
+const autoMemoryCapture = require('./lib/auto-memory-capture');
 const { readFileSync } = require('fs');
 
 // ============================================================================
@@ -94,6 +96,9 @@ async function main() {
     case 'preference-state':
       handlePreferenceState();
       break;
+    case 'auto-capture':
+      handleAutoCapture();
+      break;
     case 'help':
       printUsage();
       break;
@@ -123,6 +128,7 @@ Usage:
   node index.js detect-preferences --from <file>
   node index.js feedback-preference --label <correct|missed|wrong> --utterance "..." --expected "..."
   node index.js preference-state --query "<message>"
+  node index.js auto-capture status|enable|disable
 
 Types: decision, preference, relationship, commitment, lesson, task, project, moc
 
@@ -183,6 +189,7 @@ Examples:
   node index.js detect-preferences --from ./conversation.txt
   node index.js feedback-preference --label missed --utterance "avoid emoji" --expected "Don't use emoji."
   node index.js preference-state --query "writing a Discord reply"
+  node index.js auto-capture status
 `);
 }
 
@@ -553,6 +560,41 @@ function handleRebuildIndexes() {
   console.log('✓ Indexes rebuilt.');
 }
 
+function handleAutoCapture() {
+  const action = args[1];
+
+  if (!action || action === 'help') {
+    console.log('Usage:');
+    console.log('  node index.js auto-capture status');
+    console.log('  node index.js auto-capture enable');
+    console.log('  node index.js auto-capture disable');
+    process.exit(action ? 0 : 1);
+  }
+
+  if (action === 'status') {
+    const state = autoMemoryCapture.getAutoCaptureState(cwd);
+    console.log(`Auto-capture: ${state.enabled ? 'enabled' : 'disabled'}`);
+    console.log(`Last capture at: ${state.last_capture_at || 'never'}`);
+    console.log(`Updated at: ${state.updated_at || 'never'}`);
+    return;
+  }
+
+  if (action === 'enable') {
+    autoMemoryCapture.setAutoCaptureEnabled(true, cwd);
+    console.log('✓ Auto-capture enabled');
+    return;
+  }
+
+  if (action === 'disable') {
+    autoMemoryCapture.setAutoCaptureEnabled(false, cwd);
+    console.log('✓ Auto-capture disabled');
+    return;
+  }
+
+  console.error(`Unknown auto-capture action: ${action}`);
+  process.exit(1);
+}
+
 async function handleEmbedRebuild() {
   const options = parseArgs(args.slice(1));
   const types = options.types ? options.types.split(',').map(t => t.trim()).filter(Boolean) : undefined;

package/lib/auto-memory-capture.js

@@ -0,0 +1,270 @@
+const { existsSync, mkdirSync, readFileSync, writeFileSync } = require('fs');
+const { createHash } = require('crypto');
+const { join, dirname } = require('path');
+const store = require('./store');
+
+const DEFAULT_STATE = {
+  enabled: true,
+  updated_at: null,
+  last_capture_hash: null,
+  last_capture_at: null,
+};
+
+const DEFAULT_PATTERN_CONFIG = {
+  positive: [
+    '\\bthanks\\b',
+    '\\bthank\\s*you\\b',
+    '\\bthx\\b',
+    '\\bappreciate\\s+it\\b',
+    '\\bgood\\s+job\\b',
+    '\\bgreat\\s+job\\b',
+    '\\bnice\\s+work\\b',
+    '\\bwell\\s+done\\b',
+    '认同',
+    '同意',
+    '赞同',
+    '做得好',
+  ],
+  correction: [
+    '^no\\b',
+    "that's\\s+wrong",
+    '\\byou\\s+are\\s+wrong\\b',
+    '\\bincorrect\\b',
+    '\\bnot\\s+quite\\b',
+    '\\bactually\\b',
+    '\\bto\\s+clarify\\b',
+    '\\bthat\\s+is\\s+not\\s+right\\b',
+    '\\byou\\s+missed\\b',
+    '\\bnope\\b',
+  ],
+};
+
+function getStatePath(cwd = process.cwd()) {
+  return join(cwd, 'state', 'mcvay-mind-auto-capture.json');
+}
+
+function ensureDirectory(filePath) {
+  const directory = dirname(filePath);
+  if (directory && !existsSync(directory)) {
+    mkdirSync(directory, { recursive: true });
+  }
+}
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, value) {
+  ensureDirectory(filePath);
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function getAutoCaptureState(cwd = process.cwd()) {
+  const statePath = getStatePath(cwd);
+  if (!existsSync(statePath)) {
+    return { ...DEFAULT_STATE };
+  }
+
+  const raw = readJsonSafe(statePath);
+  if (!raw || typeof raw !== 'object') {
+    return { ...DEFAULT_STATE };
+  }
+
+  return {
+    ...DEFAULT_STATE,
+    ...raw,
+    enabled: raw.enabled !== false,
+  };
+}
+
+function setAutoCaptureEnabled(enabled, cwd = process.cwd()) {
+  const previous = getAutoCaptureState(cwd);
+  const next = {
+    ...previous,
+    enabled: Boolean(enabled),
+    updated_at: new Date().toISOString(),
+  };
+  writeJson(getStatePath(cwd), next);
+  return next;
+}
+
+function normalizePatternConfig(patternConfig = {}) {
+  const input = patternConfig && typeof patternConfig === 'object' ? patternConfig : {};
+  const positive = Array.isArray(input.positive) ? input.positive : DEFAULT_PATTERN_CONFIG.positive;
+  const correction = Array.isArray(input.correction) ? input.correction : DEFAULT_PATTERN_CONFIG.correction;
+  return {
+    positive: positive.map((v) => `${v}`.trim()).filter(Boolean),
+    correction: correction.map((v) => `${v}`.trim()).filter(Boolean),
+  };
+}
+
+function compilePatterns(patterns = []) {
+  const compiled = [];
+  for (const pattern of patterns) {
+    try {
+      compiled.push(new RegExp(pattern, 'iu'));
+    } catch {
+      // Ignore invalid regex patterns and continue.
+    }
+  }
+  return compiled;
+}
+
+function detectSignal(userMessage, patternConfig = {}) {
+  const text = `${userMessage || ''}`.trim();
+  if (!text) {
+    return { type: null, pattern: null };
+  }
+
+  const normalized = normalizePatternConfig(patternConfig);
+  const correctionPatterns = compilePatterns(normalized.correction);
+  for (const regex of correctionPatterns) {
+    if (regex.test(text)) {
+      return { type: 'correction', pattern: regex.source };
+    }
+  }
+
+  const positivePatterns = compilePatterns(normalized.positive);
+  for (const regex of positivePatterns) {
+    if (regex.test(text)) {
+      return { type: 'positive', pattern: regex.source };
+    }
+  }
+
+  return { type: null, pattern: null };
+}
+
+function createInteractionHash(userMessage, assistantResponse, signalType) {
+  return createHash('sha1')
+    .update(`${signalType || ''}\n${userMessage || ''}\n${assistantResponse || ''}`, 'utf8')
+    .digest('hex');
+}
+
+function buildLessonPayload(signal, userMessage, assistantResponse) {
+  const assistantSnippet = `${assistantResponse || ''}`.replace(/\s+/g, ' ').trim().slice(0, 160);
+  const userSnippet = `${userMessage || ''}`.replace(/\s+/g, ' ').trim().slice(0, 160);
+
+  if (signal.type === 'correction') {
+    return {
+      type: 'lesson',
+      title: 'User correction on response quality',
+      tags: ['user_correction', 'auto_capture', 'feedback'],
+      lesson_type: 'correction',
+      severity: 'moderate',
+      context: 'Automatic post-response interaction capture.',
+      outcome: 'Detected corrective user feedback and logged as actionable lesson.',
+      confidence: 95,
+      source: 'auto-capture',
+      content: [
+        '## Content',
+        'User indicated the previous response was incorrect or needed correction.',
+        '',
+        '## Context',
+        `User message: "${userSnippet || '(empty)'}"`,
+        `Assistant response excerpt: "${assistantSnippet || '(empty)'}"`,
+        '',
+        '## Takeaway',
+        'Re-check assumptions and ground future responses in the user correction.',
+      ].join('\n'),
+    };
+  }
+
+  if (signal.type === 'positive') {
+    return {
+      type: 'lesson',
+      title: 'Positive user feedback on response',
+      tags: ['positive_impact', 'auto_capture', 'feedback'],
+      lesson_type: 'success',
+      severity: 'minor',
+      context: 'Automatic post-response interaction capture.',
+      outcome: 'Detected positive reinforcement from user and logged successful approach.',
+      confidence: 88,
+      source: 'auto-capture',
+      content: [
+        '## Content',
+        'User gave positive feedback about the response.',
+        '',
+        '## Context',
+        `User message: "${userSnippet || '(empty)'}"`,
+        `Assistant response excerpt: "${assistantSnippet || '(empty)'}"`,
+        '',
+        '## Takeaway',
+        'Keep this response style and quality pattern for similar requests.',
+      ].join('\n'),
+    };
+  }
+
+  return null;
+}
+
+function captureFromInteraction({
+  userMessage = '',
+  assistantResponse = '',
+  patternConfig = {},
+  dedupeWindowMs = 10 * 60 * 1000,
+} = {}, cwd = process.cwd()) {
+  const state = getAutoCaptureState(cwd);
+  if (!state.enabled) {
+    return { captured: false, reason: 'disabled' };
+  }
+
+  const signal = detectSignal(userMessage, patternConfig);
+  if (!signal.type) {
+    return { captured: false, reason: 'no_match' };
+  }
+
+  const interactionHash = createInteractionHash(userMessage, assistantResponse, signal.type);
+  const nowMs = Date.now();
+  const previousCaptureAt = Number(new Date(state.last_capture_at || 0).getTime()) || 0;
+  const withinWindow = nowMs - previousCaptureAt >= 0 && nowMs - previousCaptureAt < dedupeWindowMs;
+  if (withinWindow && state.last_capture_hash === interactionHash) {
+    return {
+      captured: false,
+      reason: 'duplicate_recent',
+      signalType: signal.type,
+    };
+  }
+
+  const payload = buildLessonPayload(signal, userMessage, assistantResponse);
+  if (!payload) {
+    return { captured: false, reason: 'no_payload', signalType: signal.type };
+  }
+
+  const result = store.ingest(payload, cwd);
+  if (!result.success) {
+    return {
+      captured: false,
+      reason: 'ingest_failed',
+      signalType: signal.type,
+      errors: result.errors || [],
+    };
+  }
+
+  const nextState = {
+    ...state,
+    last_capture_hash: interactionHash,
+    last_capture_at: new Date(nowMs).toISOString(),
+    updated_at: new Date(nowMs).toISOString(),
+  };
+  writeJson(getStatePath(cwd), nextState);
+
+  return {
+    captured: true,
+    signalType: signal.type,
+    matchedPattern: signal.pattern,
+    slug: result.slug,
+    tags: payload.tags,
+  };
+}
+
+module.exports = {
+  DEFAULT_PATTERN_CONFIG,
+  getAutoCaptureState,
+  setAutoCaptureEnabled,
+  detectSignal,
+  captureFromInteraction,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcvay-mind",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Typed memory system with search, recall, and response guidance for agent workflows.",
   "main": "index.js",
   "bin": {