claude-mneme 2.9.1

package/scripts/mem-forget.mjs

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+/**
+ * Remove entries from the project's persistent remembered.json
+ *
+ * Usage:
+ *   node mem-forget.mjs --list                    List all entries with indices
+ *   node mem-forget.mjs --remove 0,2,3            Remove entries at indices
+ *   node mem-forget.mjs --match "description"     AI-assisted matching
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { ensureDeps, ensureMemoryDirs, loadConfig, getProjectName, invalidateCache, withFileLock } from './utils.mjs';
+
+const cwd = process.cwd();
+const paths = ensureMemoryDirs(cwd);
+const projectName = getProjectName(cwd);
+const config = loadConfig();
+
+// Parse arguments
+const args = process.argv.slice(2);
+const mode = args[0];
+
+// Read existing entries
+function readEntries() {
+  if (!existsSync(paths.remembered)) {
+    return [];
+  }
+  try {
+    return JSON.parse(readFileSync(paths.remembered, 'utf-8'));
+  } catch {
+    return [];
+  }
+}
+
+// Write entries back
+function writeEntries(entries) {
+  writeFileSync(paths.remembered, JSON.stringify(entries, null, 2) + '\n');
+  invalidateCache(cwd);
+}
+
+// Format entry for display
+function formatEntry(entry, index) {
+  const date = new Date(entry.ts).toLocaleDateString();
+  return `[${index}] (${entry.type}) ${entry.content} — ${date}`;
+}
+
+// List mode
+if (mode === '--list') {
+  const entries = readEntries();
+  if (entries.length === 0) {
+    console.log('No remembered items for this project.');
+    process.exit(0);
+  }
+
+  // Output as JSON for easy parsing by Claude
+  const output = entries.map((entry, index) => ({
+    index,
+    type: entry.type,
+    content: entry.content,
+    date: new Date(entry.ts).toLocaleDateString()
+  }));
+  console.log(JSON.stringify(output, null, 2));
+  process.exit(0);
+}
+
+// Remove mode
+if (mode === '--remove') {
+  const indicesArg = args[1];
+  if (!indicesArg) {
+    console.error('Usage: node mem-forget.mjs --remove 0,2,3');
+    process.exit(1);
+  }
+
+  const indices = indicesArg.split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
+  if (indices.length === 0) {
+    console.error('No valid indices provided.');
+    process.exit(1);
+  }
+
+  // Read-modify-write under lock to prevent lost updates from concurrent sessions
+  const lockPath = paths.remembered + '.lock';
+  const removed = withFileLock(lockPath, () => {
+    const entries = readEntries();
+    if (entries.length === 0) {
+      return null;
+    }
+
+    const invalid = indices.filter(i => i < 0 || i >= entries.length);
+    if (invalid.length > 0) {
+      console.error(`Invalid indices: ${invalid.join(', ')}. Valid range: 0-${entries.length - 1}`);
+      process.exit(1);
+    }
+
+    const removedItems = [];
+    const sortedIndices = [...indices].sort((a, b) => b - a);
+    for (const idx of sortedIndices) {
+      removedItems.unshift(entries[idx]);
+      entries.splice(idx, 1);
+    }
+
+    writeEntries(entries);
+    return removedItems;
+  }, 10);
+
+  if (!removed || removed.length === 0) {
+    console.log('No remembered items to remove.');
+    process.exit(0);
+  }
+
+  console.log(`Removed ${removed.length} item(s) from "${projectName}":`);
+  for (const entry of removed) {
+    console.log(`  - [${entry.type}] ${entry.content}`);
+  }
+  process.exit(0);
+}
+
+// Match mode (AI-assisted)
+if (mode === '--match') {
+  const query = args.slice(1).join(' ');
+  if (!query) {
+    console.error('Usage: node mem-forget.mjs --match "description of what to forget"');
+    process.exit(1);
+  }
+
+  const entries = readEntries();
+  if (entries.length === 0) {
+    console.log(JSON.stringify({ matches: [], message: 'No remembered items to search.' }));
+    process.exit(0);
+  }
+
+  // Format entries for the AI prompt
+  const entriesText = entries.map((entry, index) =>
+    `[${index}] (${entry.type}) ${entry.content}`
+  ).join('\n');
+
+  const prompt = `You are helping identify which remembered items match a user's forget request.
+
+Here are all the remembered items:
+${entriesText}
+
+The user wants to forget: "${query}"
+
+Your task: Return ONLY a JSON object with the indices of items that match what the user wants to forget.
+Format: {"indices": [0, 2], "reason": "brief explanation"}
+
+If no items match, return: {"indices": [], "reason": "No matching items found"}
+
+Be conservative - only match items that clearly relate to what the user described.
+Return ONLY the JSON object, no other text.`;
+
+  try {
+    ensureDeps();
+    const { query: agentQuery } = await import('@anthropic-ai/claude-agent-sdk');
+
+    async function* messageGenerator() {
+      yield {
+        type: 'user',
+        message: { role: 'user', content: prompt },
+        session_id: `memory-forget-${Date.now()}`,
+        parent_tool_use_id: null,
+        isSynthetic: true
+      };
+    }
+
+    const queryResult = agentQuery({
+      prompt: messageGenerator(),
+      options: {
+        model: config.model,
+        disallowedTools: ['Bash', 'Read', 'Write', 'Edit', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'Task', 'TodoWrite'],
+        pathToClaudeCodeExecutable: config.claudePath
+      }
+    });
+
+    let response = '';
+
+    try {
+      for await (const message of queryResult) {
+        if (message.type === 'assistant') {
+          const content = message.message.content;
+          response = Array.isArray(content)
+            ? content.filter(c => c.type === 'text').map(c => c.text).join('\n')
+            : typeof content === 'string' ? content : '';
+        }
+      }
+    } catch (iterError) {
+      // Agent SDK may throw on process exit even after getting response
+      if (!response && iterError.message?.includes('process exited')) {
+        console.error('[claude-mneme] Agent SDK process exit');
+      } else if (!response) {
+        throw iterError;
+      }
+    }
+
+    // Parse AI response
+    if (response) {
+      // Extract JSON from response (in case there's extra text)
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        try {
+          const result = JSON.parse(jsonMatch[0]);
+          // Enrich with entry details
+          if (result.indices && result.indices.length > 0) {
+            result.matches = result.indices.map(idx => ({
+              index: idx,
+              type: entries[idx]?.type,
+              content: entries[idx]?.content
+            })).filter(m => m.content); // Filter out invalid indices
+            result.indices = result.matches.map(m => m.index);
+          } else {
+            result.matches = [];
+          }
+          console.log(JSON.stringify(result, null, 2));
+          process.exit(0);
+        } catch {
+          // JSON parse failed
+        }
+      }
+    }
+
+    // Fallback if AI response wasn't parseable
+    console.log(JSON.stringify({
+      indices: [],
+      matches: [],
+      reason: 'Could not determine matching items. Please use --list and specify indices manually.'
+    }));
+
+  } catch (error) {
+    console.error(`[claude-mneme] AI matching error: ${error.message}`);
+    console.log(JSON.stringify({
+      indices: [],
+      matches: [],
+      reason: `AI matching failed: ${error.message}. Use --list and specify indices manually.`
+    }));
+    process.exit(1);
+  }
+
+  process.exit(0);
+}
+
+// No valid mode specified
+console.error(`Usage:
+  node mem-forget.mjs --list                    List all entries with indices
+  node mem-forget.mjs --remove 0,2,3            Remove entries at indices
+  node mem-forget.mjs --match "description"     AI-assisted matching`);
+process.exit(1);

package/scripts/mem-status.mjs

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+/**
+ * Plugin Health Check Script
+ *
+ * Checks the status of the claude-mneme plugin:
+ * - Config validity
+ * - Claude binary availability
+ * - Memory directories
+ * - Recent errors
+ * - Summary and log status
+ *
+ * Usage: node mem-status.mjs [--clear-errors]
+ */
+
+import { existsSync, readFileSync, statSync, accessSync, constants } from 'fs';
+import { execFileSync } from 'child_process';
+import {
+  MEMORY_BASE,
+  CONFIG_FILE,
+  ensureMemoryDirs,
+  loadConfig,
+  getProjectName,
+  getRecentErrors,
+  getErrorsSince,
+  clearErrorLog,
+  getErrorLogPath
+} from './utils.mjs';
+
+const cwd = process.cwd();
+const clearErrors = process.argv.includes('--clear-errors');
+
+// Clear errors if requested
+if (clearErrors) {
+  const cleared = clearErrorLog();
+  console.log(JSON.stringify({
+    action: 'clear_errors',
+    success: cleared
+  }));
+  process.exit(0);
+}
+
+const status = {
+  project: getProjectName(cwd),
+  timestamp: new Date().toISOString(),
+  overall: 'healthy', // Will be downgraded if issues found
+  checks: {},
+  errors: [],
+  warnings: []
+};
+
+// ============================================================================
+// Check 1: Config
+// ============================================================================
+try {
+  const config = loadConfig();
+  status.checks.config = {
+    status: 'ok',
+    path: CONFIG_FILE,
+    exists: existsSync(CONFIG_FILE),
+    model: config.model || 'haiku',
+    maxLogEntries: config.maxLogEntriesBeforeSummarize || 50
+  };
+
+  // Check for potentially problematic settings
+  // Only warn about claudePath if it looks like an absolute path that doesn't exist
+  if (config.claudePath && config.claudePath.startsWith('/') && !existsSync(config.claudePath)) {
+    status.checks.config.warning = `claudePath "${config.claudePath}" does not exist`;
+    status.warnings.push(`Config: claudePath not found at ${config.claudePath}`);
+  }
+} catch (err) {
+  status.checks.config = { status: 'error', message: err.message };
+  status.errors.push(`Config: ${err.message}`);
+  status.overall = 'unhealthy';
+}
+
+// ============================================================================
+// Check 2: Claude Binary
+// ============================================================================
+try {
+  const config = loadConfig();
+  let claudePath = config.claudePath || 'claude';
+
+  // Try to find claude in PATH if not specified
+  try {
+    const result = execFileSync('which', [claudePath.split('/').pop()], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+
+    if (result) {
+      status.checks.claudeBinary = {
+        status: 'ok',
+        path: result,
+        configured: config.claudePath || '(using PATH)'
+      };
+    }
+  } catch {
+    // which failed, try the configured path directly
+    if (config.claudePath && existsSync(config.claudePath)) {
+      status.checks.claudeBinary = {
+        status: 'ok',
+        path: config.claudePath,
+        configured: config.claudePath
+      };
+    } else {
+      status.checks.claudeBinary = {
+        status: 'error',
+        message: 'Claude binary not found in PATH or at configured claudePath'
+      };
+      status.errors.push('Claude binary not found - summarization will fail');
+      status.overall = 'unhealthy';
+    }
+  }
+} catch (err) {
+  status.checks.claudeBinary = { status: 'error', message: err.message };
+  status.errors.push(`Claude binary: ${err.message}`);
+  status.overall = 'unhealthy';
+}
+
+// ============================================================================
+// Check 3: Memory Directories
+// ============================================================================
+try {
+  const paths = ensureMemoryDirs(cwd);
+
+  // Check base directory
+  const baseWritable = checkWritable(MEMORY_BASE);
+
+  // Check project directory
+  const projectWritable = checkWritable(paths.project);
+
+  status.checks.directories = {
+    status: baseWritable && projectWritable ? 'ok' : 'error',
+    base: {
+      path: MEMORY_BASE,
+      exists: existsSync(MEMORY_BASE),
+      writable: baseWritable
+    },
+    project: {
+      path: paths.project,
+      exists: existsSync(paths.project),
+      writable: projectWritable
+    }
+  };
+
+  if (!baseWritable || !projectWritable) {
+    status.errors.push('Memory directories not writable');
+    status.overall = 'unhealthy';
+  }
+} catch (err) {
+  status.checks.directories = { status: 'error', message: err.message };
+  status.errors.push(`Directories: ${err.message}`);
+  status.overall = 'unhealthy';
+}
+
+// ============================================================================
+// Check 4: Memory Files Status
+// ============================================================================
+try {
+  const paths = ensureMemoryDirs(cwd);
+
+  const logExists = existsSync(paths.log);
+  const logEntries = logExists ? countLines(paths.log) : 0;
+
+  const summaryJsonExists = existsSync(paths.summaryJson);
+  const summaryMdExists = existsSync(paths.summary);
+
+  const rememberedExists = existsSync(paths.remembered);
+  let rememberedCount = 0;
+  if (rememberedExists) {
+    try {
+      const content = readFileSync(paths.remembered, 'utf-8');
+      rememberedCount = JSON.parse(content).length;
+    } catch {}
+  }
+
+  const entitiesExists = existsSync(paths.entities);
+
+  status.checks.memoryFiles = {
+    status: 'ok',
+    log: {
+      exists: logExists,
+      entries: logEntries,
+      needsSummarization: logEntries >= (loadConfig().maxLogEntriesBeforeSummarize || 50)
+    },
+    summary: {
+      jsonExists: summaryJsonExists,
+      mdExists: summaryMdExists,
+      lastUpdated: summaryJsonExists ? getFileAge(paths.summaryJson) : null
+    },
+    remembered: {
+      exists: rememberedExists,
+      count: rememberedCount
+    },
+    entities: {
+      exists: entitiesExists
+    }
+  };
+
+  // Warning if log needs summarization
+  if (status.checks.memoryFiles.log.needsSummarization) {
+    status.warnings.push(`Log has ${logEntries} entries - consider running /summarize`);
+  }
+} catch (err) {
+  status.checks.memoryFiles = { status: 'error', message: err.message };
+  status.errors.push(`Memory files: ${err.message}`);
+}
+
+// ============================================================================
+// Check 5: Recent Errors
+// ============================================================================
+try {
+  const recentErrors = getErrorsSince(24); // Last 24 hours
+  const allErrors = getRecentErrors(5); // Last 5 errors regardless of time
+
+  status.checks.errorLog = {
+    status: recentErrors.length === 0 ? 'ok' : 'warning',
+    path: getErrorLogPath(),
+    errorsLast24h: recentErrors.length,
+    recentErrors: allErrors.map(e => ({
+      time: e.ts,
+      context: e.context,
+      message: e.message
+    }))
+  };
+
+  if (recentErrors.length > 0) {
+    status.warnings.push(`${recentErrors.length} error(s) in the last 24 hours`);
+    if (status.overall === 'healthy') {
+      status.overall = 'degraded';
+    }
+  }
+} catch (err) {
+  status.checks.errorLog = { status: 'error', message: err.message };
+}
+
+// ============================================================================
+// Check 6: Sync Configuration (if enabled)
+// ============================================================================
+try {
+  const config = loadConfig();
+  const syncConfig = config.sync || {};
+
+  if (syncConfig.enabled) {
+    status.checks.sync = {
+      status: 'configured',
+      serverUrl: syncConfig.serverUrl,
+      hasApiKey: !!syncConfig.apiKey
+    };
+
+    // Try to reach the server
+    if (syncConfig.serverUrl) {
+      // We can't easily do async HTTP here, so just note it's configured
+      status.checks.sync.note = 'Server reachability not checked (use session-start to verify)';
+    }
+  } else {
+    status.checks.sync = {
+      status: 'disabled',
+      note: 'Local-only mode (default)'
+    };
+  }
+} catch (err) {
+  status.checks.sync = { status: 'error', message: err.message };
+}
+
+// ============================================================================
+// Output
+// ============================================================================
+
+// Set overall status based on errors/warnings
+if (status.errors.length > 0) {
+  status.overall = 'unhealthy';
+} else if (status.warnings.length > 0) {
+  status.overall = 'degraded';
+}
+
+console.log(JSON.stringify(status, null, 2));
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function checkWritable(dir) {
+  try {
+    accessSync(dir, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function countLines(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8').trim();
+    if (!content) return 0;
+    return content.split('\n').filter(l => l).length;
+  } catch {
+    return 0;
+  }
+}
+
+function getFileAge(filePath) {
+  try {
+    const stat = statSync(filePath);
+    const ageMs = Date.now() - stat.mtimeMs;
+    const ageHours = Math.round(ageMs / (1000 * 60 * 60) * 10) / 10;
+    if (ageHours < 1) {
+      const ageMinutes = Math.round(ageMs / (1000 * 60));
+      return `${ageMinutes} minutes ago`;
+    } else if (ageHours < 24) {
+      return `${ageHours} hours ago`;
+    } else {
+      const ageDays = Math.round(ageHours / 24 * 10) / 10;
+      return `${ageDays} days ago`;
+    }
+  } catch {
+    return 'unknown';
+  }
+}