claude-flow 3.22.0 → 3.24.0

package/.claude/helpers/.helpers-version

@@ -0,0 +1 @@
+3.23.0

package/.claude/helpers/auto-memory-hook.mjs

@@ -27,16 +27,29 @@ const CYAN = '\x1b[0;36m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 
+const YELLOW = '\x1b[0;33m';
 const log = (msg) => console.log(`${CYAN}[AutoMemory] ${msg}${RESET}`);
 const success = (msg) => console.log(`${GREEN}[AutoMemory] ✓ ${msg}${RESET}`);
 const dim = (msg) => console.log(`  ${DIM}${msg}${RESET}`);
 
+// #2545: fail LOUD instead of a silent dim skip. When @claude-flow/memory cannot
+// be resolved, self-learning imports are a no-op — the user must see this and be
+// told exactly how to fix it (on both stdout, so it shows in the Claude Code hook
+// transcript, and stderr, per the issue's requested channel).
+function warnMemoryUnavailable() {
+  const line1 = `[AutoMemory] @claude-flow/memory not resolvable from ${PROJECT_ROOT} — self-learning imports are DISABLED.`;
+  const line2 = '             Fix: npm i -D @claude-flow/memory   (or re-run: npx ruflo@latest init, then npx ruflo@latest doctor --fix)';
+  console.log(`${YELLOW}${line1}${RESET}`);
+  console.log(`${YELLOW}${line2}${RESET}`);
+  process.stderr.write(`${line1}\n${line2}\n`);
+}
+
 const DEBUG = !!(process.env.RUFLO_DEBUG || process.env.DEBUG);
 
 // ── Graceful shutdown (FIX 3) ───────────────────────────────────────────────
-// Track the backend currently in use so a SIGTERM/SIGINT mid-run can still
-// flush it (the JSON backend persists, a SQLite-backed one closes/flushes WAL)
-// instead of leaving a half-written store or a stale lock behind.
+// Track the backend in use so a SIGTERM/SIGINT mid-run can still flush it
+// (the JSON backend persists; a SQLite-backed one closes/flushes WAL) instead
+// of leaving a half-written store or a stale lock behind.
 let activeBackend = null;
 let shuttingDown = false;
 function trackBackend(b) { activeBackend = b; return b; }
@@ -151,77 +164,31 @@ class JsonFileBackend {
 // Resolve memory package path (local dev or npm installed)
 // ============================================================================
 
-/**
- * Resolve a bundled package file (`<pkg>/<relativeFile>`) by trying, in order:
- *   1. PROJECT_ROOT/v3/<pkg>/<relativeFile>           (monorepo dev layout)
- *   2. CWD/node_modules/<pkg>/<relativeFile>          (user's project deps)
- *   3. node_modules walk-up from PROJECT_ROOT
- *   4. node_modules walk-up from CWD
- *   5. Global npm prefix — checks the ruflo / claude-flow / @claude-flow/cli
- *      bundles, AND the package installed globally on its own
- *
- * Returns the resolved absolute path, or null. See issue #2285.
- */
-async function resolveBundledFile(pkg, relativeFile) {
-  const monorepo = join(PROJECT_ROOT, 'v3', pkg, relativeFile);
-  if (existsSync(monorepo)) return monorepo;
-
-  const cwd = process.env.CLAUDE_FLOW_CWD || process.cwd();
-  const inCwd = join(cwd, 'node_modules', pkg, relativeFile);
-  if (existsSync(inCwd)) return inCwd;
-
-  const walkUp = (start) => {
-    let dir = start;
-    while (dir && dir !== dirname(dir)) {
-      const candidate = join(dir, 'node_modules', pkg, relativeFile);
-      if (existsSync(candidate)) return candidate;
-      dir = dirname(dir);
-    }
-    return null;
-  };
-
-  const fromProject = walkUp(PROJECT_ROOT);
-  if (fromProject) return fromProject;
-
-  const fromCwd = walkUp(cwd);
-  if (fromCwd) return fromCwd;
-
-  // Global npm prefix fallback — handles `npm i -g ruflo` and friends, where
-  // the marketplace clone (PROJECT_ROOT) has no access to the bundled deps.
+async function loadMemoryPackage() {
+  // Strategy 0 (#2545): sidecar recorded by `init` / `doctor --fix`. On the
+  // documented `npx ruflo` path @claude-flow/memory (an optionalDependency of
+  // the CLI) lands in the npx cache, which is NOT on the walk-up path from the
+  // project — so init resolves it from the CLI's own context and records the
+  // absolute path here. This is the only strategy that works on that install.
   try {
-    const { execSync } = await import('child_process');
-    const npmPrefix = execSync('npm prefix -g', {
-      encoding: 'utf-8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim();
-    if (npmPrefix) {
-      // Both Unix (<prefix>/lib/node_modules) and Windows (<prefix>/node_modules)
-      const roots = [join(npmPrefix, 'lib', 'node_modules'), join(npmPrefix, 'node_modules')];
-      const wrappers = ['ruflo', 'claude-flow', join('@claude-flow', 'cli')];
-      for (const root of roots) {
-        for (const wrapper of wrappers) {
-          const candidate = join(root, wrapper, 'node_modules', pkg, relativeFile);
-          if (existsSync(candidate)) return candidate;
-        }
-        const direct = join(root, pkg, relativeFile);
-        if (existsSync(direct)) return direct;
+    const sidecar = join(PROJECT_ROOT, '.claude-flow', 'memory-package.json');
+    if (existsSync(sidecar)) {
+      const rec = JSON.parse(readFileSync(sidecar, 'utf-8'));
+      if (rec?.distPath && existsSync(rec.distPath)) {
+        return await import(`file://${rec.distPath}`);
       }
     }
-  } catch { /* npm not on PATH or no global install */ }
-
-  return null;
-}
+  } catch { /* fall through */ }
 
-async function loadMemoryPackage() {
-  // Strategy 1-5: locate dist/index.js across dev/installed/global layouts
-  const resolved = await resolveBundledFile('@claude-flow/memory', 'dist/index.js');
-  if (resolved) {
+  // Strategy 1: Local dev (built dist)
+  const localDist = join(PROJECT_ROOT, 'v3/@claude-flow/memory/dist/index.js');
+  if (existsSync(localDist)) {
     try {
-      return await import(`file://${resolved}`);
+      return await import(`file://${localDist}`);
     } catch { /* fall through */ }
   }
 
-  // Strategy 6: Use createRequire for CJS-style resolution (handles nested node_modules
+  // Strategy 2: Use createRequire for CJS-style resolution (handles nested node_modules
   // when installed as a transitive dependency via npx ruflo / npx claude-flow)
   try {
     const { createRequire } = await import('module');
@@ -229,11 +196,24 @@ async function loadMemoryPackage() {
     return require('@claude-flow/memory');
   } catch { /* fall through */ }
 
-  // Strategy 7: ESM import (works when @claude-flow/memory is a direct dependency)
+  // Strategy 3: ESM import (works when @claude-flow/memory is a direct dependency)
   try {
     return await import('@claude-flow/memory');
   } catch { /* fall through */ }
 
+  // Strategy 4: Walk up from PROJECT_ROOT looking for @claude-flow/memory in any node_modules
+  let searchDir = PROJECT_ROOT;
+  const { parse } = await import('path');
+  while (searchDir !== parse(searchDir).root) {
+    const candidate = join(searchDir, 'node_modules', '@claude-flow', 'memory', 'dist', 'index.js');
+    if (existsSync(candidate)) {
+      try {
+        return await import(`file://${candidate}`);
+      } catch { /* fall through */ }
+    }
+    searchDir = dirname(searchDir);
+  }
+
   return null;
 }
 
@@ -283,7 +263,7 @@ async function doImport() {
 
   const memPkg = await loadMemoryPackage();
   if (!memPkg || !memPkg.AutoMemoryBridge) {
-    dim('Memory package not available — skipping auto memory import');
+    warnMemoryUnavailable();
     return;
   }
 
@@ -292,10 +272,7 @@ async function doImport() {
   await backend.initialize();
 
   const bridgeConfig = {
-    // Use Claude Code's invocation cwd (the user's project), not PROJECT_ROOT
-    // — PROJECT_ROOT resolves to the plugin clone when this hook runs from
-    // ~/.claude/plugins/marketplaces/ruflo/. See issue #2284.
-    workingDir: process.env.CLAUDE_FLOW_CWD || process.cwd(),
+    workingDir: PROJECT_ROOT,
     syncMode: 'on-session-end',
   };
 
@@ -327,36 +304,6 @@ async function doImport() {
     dim(`├─ Learning: ${config.learningBridge.enabled ? 'active' : 'disabled'}`);
     dim(`├─ Graph: ${config.memoryGraph.enabled ? 'active' : 'disabled'}`);
     dim(`└─ Agent scopes: ${config.agentScopes.enabled ? 'active' : 'disabled'}`);
-
-    // Bridge to AgentDB: store entries with ONNX vector embeddings for semantic search
-    let vectorized = 0;
-    try {
-      const cliDistPath = await resolveBundledFile('@claude-flow/cli', 'dist/src/memory/memory-initializer.js');
-      if (cliDistPath) {
-        const memInit = await import(`file://${cliDistPath}`);
-        await memInit.initializeMemoryDatabase({ force: false, verbose: false });
-
-        const entries = await backend.query({});
-        for (const entry of entries) {
-          if (!entry.content || entry.content.length < 10) continue;
-          try {
-            await memInit.storeEntry({
-              key: entry.key || entry.id,
-              value: entry.content,
-              namespace: entry.namespace || 'auto-memory',
-              generateEmbeddingFlag: true,
-            });
-            vectorized++;
-          } catch { /* skip entries that fail to embed */ }
-        }
-
-        if (vectorized > 0) {
-          success(`Vectorized ${vectorized} entries into AgentDB (ONNX 384-dim)`);
-        }
-      }
-    } catch (vecErr) {
-      dim(`AgentDB vectorization skipped: ${vecErr.message?.slice(0, 60)}`);
-    }
   } catch (err) {
     dim(`Import failed (non-critical): ${err.message}`);
   }
@@ -369,7 +316,7 @@ async function doSync() {
 
   const memPkg = await loadMemoryPackage();
   if (!memPkg || !memPkg.AutoMemoryBridge) {
-    dim('Memory package not available — skipping sync');
+    warnMemoryUnavailable();
     return;
   }
 
@@ -385,8 +332,7 @@ async function doSync() {
   }
 
   const bridgeConfig = {
-    // See doImport — must reflect the user's project, not PROJECT_ROOT (#2284)
-    workingDir: process.env.CLAUDE_FLOW_CWD || process.cwd(),
+    workingDir: PROJECT_ROOT,
     syncMode: 'on-session-end',
   };
 
@@ -416,21 +362,6 @@ async function doSync() {
     // Curate MEMORY.md index with graph-aware ordering
     await bridge.curateIndex();
     success('Curated MEMORY.md index');
-
-    // Flush intelligence patterns to disk (SONA + ReasoningBank)
-    try {
-      const intPath = await resolveBundledFile('@claude-flow/cli', 'dist/src/memory/intelligence.js');
-      if (intPath) {
-        const intelligence = await import(`file://${intPath}`);
-        if (intelligence.flushPatterns) {
-          intelligence.flushPatterns();
-          const stats = intelligence.getIntelligenceStats?.();
-          if (stats && stats.patternsLearned > 0) {
-            success(`Flushed ${stats.patternsLearned} learned patterns to disk`);
-          }
-        }
-      }
-    } catch { /* non-critical */ }
   } catch (err) {
     dim(`Sync failed (non-critical): ${err.message}`);
   }
@@ -443,8 +374,12 @@ async function doStatus() {
   const memPkg = await loadMemoryPackage();
   const config = readConfig();
 
+  const sidecar = join(PROJECT_ROOT, '.claude-flow', 'memory-package.json');
+  const hasSidecar = existsSync(sidecar);
+
   console.log('\n=== Auto Memory Bridge Status ===\n');
-  console.log(`  Package:        ${memPkg ? '✅ Available' : '❌ Not found'}`);
+  console.log(`  Package:        ${memPkg ? '✅ Available' : '❌ Not found — self-learning DISABLED (fix: npm i -D @claude-flow/memory)'}`);
+  console.log(`  Resolver:       ${hasSidecar ? '✅ .claude-flow/memory-package.json' : '⏸ no sidecar (run: npx ruflo@latest doctor --fix)'}`);
   console.log(`  Store:          ${existsSync(STORE_PATH) ? '✅ ' + STORE_PATH : '⏸ Not initialized'}`);
   console.log(`  LearningBridge: ${config.learningBridge.enabled ? '✅ Enabled' : '⏸ Disabled'}`);
   console.log(`  MemoryGraph:    ${config.memoryGraph.enabled ? '✅ Enabled' : '⏸ Disabled'}`);
@@ -457,158 +392,9 @@ async function doStatus() {
     } catch { /* ignore */ }
   }
 
-  // AgentDB vector status
-  try {
-    const dbPath = join(PROJECT_ROOT, '.claude-flow', 'memory', 'memory.db');
-    const swarmDbPath = join(PROJECT_ROOT, '.swarm', 'memory.db');
-    const hasDb = existsSync(dbPath) || existsSync(swarmDbPath);
-    console.log(`  AgentDB:        ${hasDb ? '✅ sql.js database exists' : '⏸ Not initialized'}`);
-
-    const intPath = await resolveBundledFile('@claude-flow/cli', 'dist/src/memory/intelligence.js');
-    if (intPath) {
-      const intelligence = await import(`file://${intPath}`);
-      const stats = intelligence.getIntelligenceStats?.();
-      if (stats) {
-        console.log(`  SONA:           ${stats.sonaEnabled ? '✅ Active' : '⏸ Not initialized'}`);
-        console.log(`  Patterns:       ${stats.patternsLearned} learned`);
-        console.log(`  Trajectories:   ${stats.trajectoriesRecorded} recorded`);
-      }
-    }
-  } catch { /* ignore */ }
-
   console.log('');
 }
 
-// ============================================================================
-// Import ALL Claude Code memories from all projects into AgentDB
-// ============================================================================
-
-async function doImportAll() {
-  log('Importing ALL Claude Code memories into AgentDB...');
-
-  const { homedir } = await import('os');
-  const { readdirSync } = await import('fs');
-  const claudeProjectsDir = join(homedir(), '.claude', 'projects');
-
-  if (!existsSync(claudeProjectsDir)) {
-    dim('No Claude Code projects found at ' + claudeProjectsDir);
-    return;
-  }
-
-  // Find all memory files across all projects
-  const memoryFiles = [];
-  try {
-    const projects = readdirSync(claudeProjectsDir, { withFileTypes: true });
-    for (const project of projects) {
-      if (!project.isDirectory()) continue;
-      const memDir = join(claudeProjectsDir, project.name, 'memory');
-      if (!existsSync(memDir)) continue;
-      const files = readdirSync(memDir).filter(f => f.endsWith('.md'));
-      for (const file of files) {
-        memoryFiles.push({
-          path: join(memDir, file),
-          project: project.name,
-          file,
-        });
-      }
-    }
-  } catch (err) {
-    dim('Error scanning projects: ' + err.message);
-    return;
-  }
-
-  if (memoryFiles.length === 0) {
-    dim('No memory files found');
-    return;
-  }
-
-  log(`Found ${memoryFiles.length} memory files across ${new Set(memoryFiles.map(f => f.project)).size} projects`);
-
-  // Load memory-initializer for vectorized storage
-  let memInit = null;
-  try {
-    const cliDistPath = await resolveBundledFile('@claude-flow/cli', 'dist/src/memory/memory-initializer.js');
-    if (cliDistPath) {
-      memInit = await import(`file://${cliDistPath}`);
-      await memInit.initializeMemoryDatabase({ force: false, verbose: false });
-    }
-  } catch (err) {
-    dim('Memory initializer not available: ' + err.message?.slice(0, 60));
-  }
-
-  if (!memInit) {
-    dim('Cannot vectorize without memory-initializer. Run: cd v3/@claude-flow/cli && npm run build');
-    return;
-  }
-
-  let imported = 0;
-  let skipped = 0;
-
-  for (const memFile of memoryFiles) {
-    try {
-      const content = readFileSync(memFile.path, 'utf-8');
-
-      // Parse YAML frontmatter + body
-      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-      let name = memFile.file.replace('.md', '');
-      let description = '';
-      let type = 'auto-memory';
-      let body = content;
-
-      if (frontmatterMatch) {
-        const yaml = frontmatterMatch[1];
-        body = frontmatterMatch[2].trim();
-        const nameMatch = yaml.match(/^name:\s*(.+)$/m);
-        const descMatch = yaml.match(/^description:\s*(.+)$/m);
-        const typeMatch = yaml.match(/^type:\s*(.+)$/m);
-        if (nameMatch) name = nameMatch[1].trim();
-        if (descMatch) description = descMatch[1].trim();
-        if (typeMatch) type = typeMatch[1].trim();
-      }
-
-      // Split body into sections (## headers) for granular entries
-      const sections = body.split(/^(?=## )/m).filter(s => s.trim().length > 20);
-
-      if (sections.length === 0) {
-        // Store whole file as one entry
-        if (body.length > 10) {
-          await memInit.storeEntry({
-            key: `claude-memory:${memFile.project}:${name}`,
-            value: body.slice(0, 4096),
-            namespace: 'claude-memories',
-            generateEmbeddingFlag: true,
-          });
-          imported++;
-        }
-      } else {
-        // Store each section separately for better search granularity
-        for (const section of sections) {
-          const titleMatch = section.match(/^##\s+(.+)/);
-          const sectionTitle = titleMatch ? titleMatch[1].trim() : name;
-          const sectionBody = section.replace(/^##\s+.+\n/, '').trim();
-          if (sectionBody.length < 10) continue;
-
-          await memInit.storeEntry({
-            key: `claude-memory:${memFile.project}:${name}:${sectionTitle.slice(0, 50)}`,
-            value: sectionBody.slice(0, 4096),
-            namespace: 'claude-memories',
-            generateEmbeddingFlag: true,
-          });
-          imported++;
-        }
-      }
-
-      dim(`  ✓ ${memFile.project}/${memFile.file} (${sections.length || 1} entries)`);
-    } catch (err) {
-      dim(`  ✗ ${memFile.project}/${memFile.file}: ${err.message?.slice(0, 60)}`);
-      skipped++;
-    }
-  }
-
-  success(`Imported ${imported} entries from ${memoryFiles.length} files (${skipped} skipped)`);
-  success('All Claude Code memories now searchable via AgentDB vector search');
-}
-
 // ============================================================================
 // Main
 // ============================================================================
@@ -630,16 +416,15 @@ process.on('unhandledRejection', (reason) => {
 try {
   switch (command) {
     case 'import': await doImport(); break;
-    case 'import-all': await doImportAll(); break;
     case 'sync': await doSync(); break;
     case 'status': await doStatus(); break;
     default:
       console.log('Usage: auto-memory-hook.mjs <import|sync|status>');
-      process.exit(1);
+      break;
   }
 } catch (err) {
   // Hooks must never crash Claude Code - fail silently
-  dim(`Error (non-critical): ${err.message}`);
+  try { dim(`Error (non-critical): ${err.message}`); } catch (_) {}
 }
-// Ensure clean exit for Claude Code hooks (exit 0 = success, no stderr = no error)
+// Force clean exit — process.exitCode alone isn't enough if async errors override it
 process.exit(0);

package/.claude/helpers/helpers.manifest.json

@@ -0,0 +1,12 @@
+{
+  "manifest": {
+    "version": "3.23.0",
+    "files": {
+      "auto-memory-hook.mjs": "68be7e9a9eba7bf9c4e8a230db7bf61a243b965639f8504842799d6c6ca28762",
+      "hook-handler.cjs": "bc4d2d26823d49b3ab1dded2946b66369f1f67bd76b4c30dca9f3b6df3cca8f0",
+      "intelligence.cjs": "760cb82ed2000031abc1ac1fa90a014e7d91d93966e3aa4741b07ab7aff8d066"
+    }
+  },
+  "signature": "of5l9RP68iPcmcC5dckDv+KIOiENJKifWxYKwQTwAiXiyRNNZuMwQ8y8Bd8+wGviTRxIzBfSuxL1nuJ/rX3xDQ==",
+  "algorithm": "ed25519"
+}