@ghl-ai/aw 0.1.37-beta.41 → 0.1.37-beta.43

package/commands/memory.mjs

@@ -1,7 +1,9 @@
-// commands/memory.mjs — `aw memory [store|search|pack|stats|validate|invalidate|sync|audit]`
+// commands/memory.mjs — `aw memory [store|search|pack|stats|validate|invalidate|sync|audit|review|promote]`
 
 import { join } from 'node:path';
+import { readFileSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
+import { confirm, isCancel } from '@clack/prompts';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { callMemoryTool } from '../memory-bridge.mjs';
@@ -19,6 +21,8 @@ export async function memoryCommand(args) {
     case 'invalidate': return memoryInvalidate(args);
     case 'sync':       return memorySync(args);
     case 'audit':      return memoryAudit(args);
+    case 'review':     return memoryReview(args);
+    case 'promote':    return memoryPromote(args);
     default:           return memoryHelp();
   }
 }
@@ -461,6 +465,363 @@ function getQualityIssue(content) {
   return 'Low specificity';
 }
 
+// ── review ───────────────────────────────────────────────────────────
+
+async function memoryReview(args) {
+  fmt.intro('aw memory review');
+
+  const threshold = parseFloat(args['--threshold'] || '0.6');
+  const limit = parseInt(args['--limit'] || '50', 10);
+
+  const s = fmt.spinner();
+  s.start('Fetching memories for review...');
+
+  try {
+    const result = await callMemoryTool('memory_search', { query: '*', limit });
+    const allMemories = Array.isArray(result) ? result : (result?.memories ?? result?.results ?? []);
+
+    if (allMemories.length === 0) {
+      s.stop('No memories found');
+      fmt.outro('Nothing to review');
+      return;
+    }
+
+    // Filter for low-confidence memories
+    const needsReview = allMemories.filter(mem => {
+      const conf = mem.classification_confidence ?? mem.confidence;
+      // If confidence field exists, use the threshold; otherwise include it as "unknown confidence"
+      if (conf != null) return conf < threshold;
+      // No confidence field — treat as needing review (proxy: confidence unknown)
+      return true;
+    });
+
+    s.stop(`Found ${needsReview.length} memor${needsReview.length === 1 ? 'y' : 'ies'} to review (of ${allMemories.length} fetched)`);
+
+    if (needsReview.length === 0) {
+      fmt.logInfo('All memories have confidence above threshold. Nothing to review.');
+      fmt.outro('Review complete');
+      return;
+    }
+
+    let validated = 0;
+    let invalidated = 0;
+    let skipped = 0;
+
+    for (let i = 0; i < needsReview.length; i++) {
+      const mem = needsReview[i];
+      const content = mem.content ?? mem.text ?? JSON.stringify(mem);
+      const conf = mem.classification_confidence ?? mem.confidence;
+      const overlays = Array.isArray(mem.overlay) ? mem.overlay.join(', ') : (mem.overlay || '-');
+      const angles = Array.isArray(mem.angle) ? mem.angle.join(', ') : (mem.angle || '-');
+
+      const infoLines = [
+        `${chalk.dim('content:')}    ${content}`,
+        `${chalk.dim('layer:')}      ${chalk.cyan(mem.layer || 'unclassified')}`,
+        `${chalk.dim('overlay:')}    ${chalk.magenta(overlays)}`,
+        `${chalk.dim('angle:')}      ${chalk.yellow(angles)}`,
+        `${chalk.dim('confidence:')} ${conf != null ? (conf < threshold ? chalk.red(conf) : chalk.green(conf)) : chalk.dim('unknown')}`,
+        mem.id ? `${chalk.dim('id:')}         ${mem.id}` : null,
+        mem.type ? `${chalk.dim('type:')}       ${mem.type}` : null,
+      ].filter(Boolean).join('\n');
+
+      fmt.note(infoLines, `Memory ${i + 1}/${needsReview.length}`);
+
+      const action = await fmt.select({
+        message: 'What would you like to do with this memory?',
+        options: [
+          { value: 'confirm', label: 'Confirm', hint: 'validate this memory' },
+          { value: 'invalidate', label: 'Invalidate', hint: 'mark as invalid' },
+          { value: 'skip', label: 'Skip', hint: 'move to next' },
+          { value: 'quit', label: 'Quit review', hint: 'stop reviewing' },
+        ],
+      });
+
+      if (fmt.isCancel(action) || action === 'quit') {
+        fmt.logInfo('Review stopped by user.');
+        break;
+      }
+
+      if (action === 'skip') {
+        skipped++;
+        continue;
+      }
+
+      if (!mem.id) {
+        fmt.logWarn('Memory has no ID — cannot send feedback. Skipping.');
+        skipped++;
+        continue;
+      }
+
+      const feedbackType = action === 'confirm' ? 'validate' : 'invalidate';
+
+      try {
+        await callMemoryTool('memory_feedback', {
+          memory_id: mem.id,
+          feedback_type: feedbackType,
+          actor_type: 'user',
+        });
+
+        if (action === 'confirm') {
+          validated++;
+          fmt.logSuccess(`Memory ${mem.id.slice(0, 8)} validated`);
+        } else {
+          invalidated++;
+          fmt.logWarn(`Memory ${mem.id.slice(0, 8)} invalidated`);
+        }
+      } catch (err) {
+        fmt.logError(`Feedback failed for ${mem.id.slice(0, 8)}: ${err.message}`);
+        skipped++;
+      }
+    }
+
+    const summaryLines = [
+      `  ${chalk.green('Validated:')}    ${validated}`,
+      `  ${chalk.red('Invalidated:')}  ${invalidated}`,
+      `  ${chalk.dim('Skipped:')}      ${skipped}`,
+    ].join('\n');
+    fmt.note(summaryLines, 'Review Summary');
+    fmt.outro('Review complete');
+  } catch (err) {
+    s.stop(chalk.red('Failed'));
+    fmt.cancel(`Review failed: ${err.message}`);
+  }
+}
+
+// ── promote ──────────────────────────────────────────────────────────
+
+async function memoryPromote(args) {
+  fmt.intro('aw memory promote');
+
+  const limit = parseInt(args['--limit'] || '200', 10);
+  const minOccurrences = parseInt(args['--min'] || '3', 10);
+  const cwd = process.cwd();
+
+  // Step 1: Find the project matching cwd from homunculus projects.json
+  const projectsPath = join(homedir(), '.claude', 'homunculus', 'projects.json');
+  if (!existsSync(projectsPath)) {
+    fmt.cancel('No homunculus projects.json found at ' + projectsPath);
+    return;
+  }
+
+  let projects;
+  try {
+    projects = JSON.parse(readFileSync(projectsPath, 'utf8'));
+  } catch (err) {
+    fmt.cancel(`Failed to parse projects.json: ${err.message}`);
+    return;
+  }
+
+  // projects.json maps hashes to { name, root, remote, ... }
+  const entries = Object.entries(projects);
+  const match = entries.find(([, proj]) => {
+    const root = proj.root || proj.path;
+    if (!root) return false;
+    // Match if cwd starts with the project root (handles subdirectories)
+    return cwd === root || cwd.startsWith(root + '/');
+  });
+
+  if (!match) {
+    fmt.cancel(`No homunculus project found matching cwd: ${cwd}`);
+    fmt.logInfo('Known project roots:');
+    for (const [hash, proj] of entries) {
+      fmt.logInfo(`  ${chalk.dim(hash.slice(0, 8))} ${proj.root || proj.path || '?'} ${chalk.cyan(proj.name || '')}`);
+    }
+    return;
+  }
+
+  const [projectHash, projectInfo] = match;
+  const projectName = projectInfo.name || projectHash.slice(0, 8);
+  fmt.logStep(`Project: ${chalk.cyan(projectName)} ${chalk.dim(`(${projectHash.slice(0, 8)})`)}`);
+
+  // Step 2: Read observations.jsonl
+  const observationsPath = join(homedir(), '.claude', 'homunculus', 'projects', projectHash, 'observations.jsonl');
+  if (!existsSync(observationsPath)) {
+    fmt.cancel(`No observations file found at ${observationsPath}`);
+    return;
+  }
+
+  let lines;
+  try {
+    const raw = readFileSync(observationsPath, 'utf8');
+    lines = raw.trim().split('\n').filter(Boolean);
+  } catch (err) {
+    fmt.cancel(`Failed to read observations: ${err.message}`);
+    return;
+  }
+
+  if (lines.length === 0) {
+    fmt.cancel('Observations file is empty.');
+    return;
+  }
+
+  // Take the last N observations
+  const recentLines = lines.slice(-limit);
+  fmt.logStep(`Read ${recentLines.length} observations (of ${lines.length} total)`);
+
+  // Step 3: Parse and extract tool + outcome patterns
+  const observations = [];
+  for (const line of recentLines) {
+    try {
+      observations.push(JSON.parse(line));
+    } catch {
+      // skip malformed lines
+    }
+  }
+
+  if (observations.length === 0) {
+    fmt.cancel('No valid observations found.');
+    return;
+  }
+
+  // Group by tool name + outcome (success/failure)
+  const patternCounts = new Map();    // "tool:outcome" -> count
+  const patternSessions = new Map();  // "tool:outcome" -> Set<sessionId>
+  const patternExamples = new Map();  // "tool:outcome" -> first example observation
+
+  for (const obs of observations) {
+    const tool = obs.tool || obs.toolName || obs.tool_name || 'unknown';
+    const outcome = obs.outcome || obs.status || (obs.error ? 'failure' : 'success');
+    const session = obs.session || obs.sessionId || obs.session_id || 'default';
+    const key = `${tool}:${outcome}`;
+
+    patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
+
+    if (!patternSessions.has(key)) patternSessions.set(key, new Set());
+    patternSessions.get(key).add(session);
+
+    if (!patternExamples.has(key)) patternExamples.set(key, obs);
+  }
+
+  // Step 4: Filter for high-frequency patterns (appearing minOccurrences+ times across 2+ sessions)
+  const promotable = [];
+  for (const [key, count] of patternCounts) {
+    const sessionCount = patternSessions.get(key).size;
+    if (count >= minOccurrences && sessionCount >= 2) {
+      const [tool, outcome] = key.split(':');
+      const example = patternExamples.get(key);
+      promotable.push({ tool, outcome, count, sessionCount, example });
+    }
+  }
+
+  // Sort by count descending
+  promotable.sort((a, b) => b.count - a.count);
+
+  if (promotable.length === 0) {
+    fmt.logInfo(`No patterns found with ${minOccurrences}+ occurrences across 2+ sessions.`);
+    fmt.logInfo('Try lowering the threshold with --min <n>.');
+
+    // Show top patterns anyway for visibility
+    const topPatterns = [...patternCounts.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10);
+    if (topPatterns.length > 0) {
+      const topLines = topPatterns
+        .map(([key, count]) => {
+          const sessions = patternSessions.get(key).size;
+          const [tool, outcome] = key.split(':');
+          const outcomeColor = outcome === 'success' ? chalk.green(outcome) : chalk.red(outcome);
+          return `  ${chalk.cyan(tool.padEnd(30))} ${outcomeColor.padEnd(20)} ${chalk.dim(`${count}x, ${sessions} session${sessions !== 1 ? 's' : ''}`)}`;
+        })
+        .join('\n');
+      fmt.note(topLines, 'Top patterns (below threshold)');
+    }
+    fmt.outro('Nothing to promote');
+    return;
+  }
+
+  // Step 5: Show summary of what would be promoted
+  const summaryLines = promotable.map(p => {
+    const outcomeColor = p.outcome === 'success' ? chalk.green(p.outcome) : chalk.red(p.outcome);
+    return `  ${chalk.cyan(p.tool.padEnd(30))} ${outcomeColor.padEnd(20)} ${chalk.dim(`${p.count}x across ${p.sessionCount} sessions`)}`;
+  }).join('\n');
+
+  fmt.note(summaryLines, `${promotable.length} pattern${promotable.length !== 1 ? 's' : ''} to promote`);
+
+  // Step 6: Ask for confirmation (skip if --yes flag)
+  if (!args['--yes'] && !args['-y']) {
+    try {
+      const shouldPromote = await confirm({
+        message: `Promote ${promotable.length} pattern${promotable.length !== 1 ? 's' : ''} to team memory?`,
+      });
+      if (isCancel(shouldPromote) || !shouldPromote) {
+        fmt.logInfo('Promotion cancelled.');
+        fmt.outro('No patterns promoted');
+        return;
+      }
+    } catch {
+      // TTY not available (e.g., running inside Claude Code) — proceed
+    }
+  }
+
+  // Step 7: Promote each pattern via memory_store
+  const s = fmt.spinner();
+  s.start('Promoting patterns to team memory...');
+
+  let promoted = 0;
+  let failed = 0;
+
+  for (const p of promotable) {
+    const content = buildPromoteContent(p, projectName);
+
+    try {
+      await callMemoryTool('memory_store', {
+        content,
+        type: 'pattern',
+        curate: true,
+        source: 'instinct-promotion',
+      });
+      promoted++;
+    } catch (err) {
+      failed++;
+      fmt.logError(`Failed to promote ${p.tool}:${p.outcome}: ${err.message}`);
+    }
+  }
+
+  s.stop('Promotion complete');
+
+  // Step 8: Report
+  const resultLines = [
+    `  ${chalk.green('Promoted:')}  ${promoted}`,
+    failed > 0 ? `  ${chalk.red('Failed:')}    ${failed}` : null,
+    `  ${chalk.dim('Project:')}   ${projectName}`,
+    `  ${chalk.dim('Source:')}    ${observationsPath}`,
+  ].filter(Boolean).join('\n');
+
+  fmt.note(resultLines, 'Promote Summary');
+  fmt.outro(`${promoted} pattern${promoted !== 1 ? 's' : ''} promoted to team memory`);
+}
+
+/**
+ * Build a human-readable memory content string from a tool pattern.
+ */
+function buildPromoteContent(pattern, projectName) {
+  const { tool, outcome, count, sessionCount, example } = pattern;
+  const parts = [
+    `[${projectName}] Tool pattern: "${tool}" consistently ${outcome === 'success' ? 'succeeds' : 'fails'}.`,
+    `Observed ${count} times across ${sessionCount} sessions.`,
+  ];
+
+  // Add context from the example observation if available
+  if (example) {
+    if (example.input || example.args) {
+      const input = example.input || example.args;
+      const inputStr = typeof input === 'string' ? input : JSON.stringify(input);
+      if (inputStr.length <= 200) {
+        parts.push(`Example input: ${inputStr}`);
+      }
+    }
+    if (outcome !== 'success' && (example.error || example.errorMessage || example.error_message)) {
+      const errMsg = example.error || example.errorMessage || example.error_message;
+      const errStr = typeof errMsg === 'string' ? errMsg : JSON.stringify(errMsg);
+      if (errStr.length <= 200) {
+        parts.push(`Common error: ${errStr}`);
+      }
+    }
+  }
+
+  return parts.join(' ');
+}
+
 // ── help ─────────────────────────────────────────────────────────────
 
 function memoryHelp() {
@@ -508,6 +869,14 @@ function memoryHelp() {
     cmd('  --sample <n>', 'Sample size (default: 30)'),
     cmd('  --days <n>', 'Days to look back (default: 30)'),
     '',
+    cmd('aw memory review', 'Interactively review low-confidence memories'),
+    cmd('  --threshold <n>', 'Confidence threshold (default: 0.6)'),
+    cmd('  --limit <n>', 'Max memories to fetch (default: 50)'),
+    '',
+    cmd('aw memory promote', 'Promote local instincts to team memory'),
+    cmd('  --limit <n>', 'Observations to scan (default: 200)'),
+    cmd('  --min <n>', 'Min occurrences to promote (default: 3)'),
+    '',
   ].join('\n');
 
   console.log(help);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.41",
+  "version": "0.1.37-beta.43",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",