claude-flow 3.7.0-alpha.27 → 3.7.0-alpha.29

package/.claude/helpers/hook-handler.cjs

@@ -100,7 +100,10 @@ async function main() {
   var toolInput = hookInput.toolInput || hookInput.tool_input || {};
   var toolName = hookInput.toolName || hookInput.tool_name || '';
 
-  var prompt = hookInput.prompt || hookInput.command || toolInput
+  // `toolInput` is an object (e.g. {command:"ls"}) — falling back to it
+  // directly bound `prompt` to the object and tripped `.toLowerCase()` /
+  // `.substring()` on every Bash hook (#1944). Use the `.command` field.
+  var prompt = hookInput.prompt || hookInput.command || toolInput.command
     || process.env.PROMPT || process.env.TOOL_INPUT_command || '';
 
 const handlers = {

package/.claude/helpers/statusline.cjs

@@ -26,18 +26,29 @@ const CONFIG = {
 
 const CWD = process.cwd();
 
-// Read package version once at startup
+// Read package version once at startup. Probe the plugin's own install
+// location first — `~/.claude/plugins/marketplaces/ruflo/package.json` — so
+// users who installed via `/plugin install ruflo@ruflo` see the real version,
+// not the hardcoded fallback (#1951).
 let pkgVersion = '3.5';
 try {
+  const os = require('os');
+  const home = os.homedir();
   const pkgPaths = [
+    path.join(home, '.claude', 'plugins', 'marketplaces', 'ruflo', 'package.json'),
     path.join(CWD, 'node_modules', '@claude-flow', 'cli', 'package.json'),
+    path.join(CWD, 'node_modules', 'ruflo', 'package.json'),
     path.join(CWD, 'v3', '@claude-flow', 'cli', 'package.json'),
   ];
   for (const p of pkgPaths) {
-    if (fs.existsSync(p)) {
+    if (!fs.existsSync(p)) continue;
+    try {
       const pkg = JSON.parse(fs.readFileSync(p, 'utf-8'));
-      if (pkg.version) { pkgVersion = pkg.version; break; }
-    }
+      if (pkg && typeof pkg.version === 'string' && pkg.version.length > 0) {
+        pkgVersion = pkg.version;
+        break;
+      }
+    } catch { /* malformed package.json — try next */ }
   }
 } catch { /* use default */ }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.27",
+  "version": "3.7.0-alpha.29",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",
@@ -152,4 +152,4 @@
     "access": "public",
     "tag": "latest"
   }
-}
+}

package/v3/@claude-flow/cli/dist/src/commands/doctor.js

@@ -139,12 +139,23 @@ async function checkDaemonStatus() {
 }
 // Check memory database
 async function checkMemoryDatabase() {
-    const dbPaths = [
-        '.claude-flow/memory.db',
-        '.swarm/memory.db',
-        'data/memory.db'
-    ];
-    for (const dbPath of dbPaths) {
+    // Authoritative path comes from `getMemoryRoot()` (honors
+    // `CLAUDE_FLOW_MEMORY_PATH`, claude-flow.config.json's `memory.persistPath`,
+    // then defaults to `.swarm/`). #1946: the previous hard-coded list missed
+    // `data/memory/memory.db` (a common config) and ignored the env var
+    // entirely, so doctor reported "Not initialized" on perfectly-init'd DBs.
+    // Try the configured path first, then fall back to the historic candidates.
+    const candidates = [];
+    try {
+        const { getMemoryRoot } = await import('../memory/memory-initializer.js');
+        candidates.push(join(getMemoryRoot(), 'memory.db'));
+    }
+    catch {
+        /* memory-initializer not available — fall through to legacy candidates */
+    }
+    candidates.push('.swarm/memory.db', '.claude-flow/memory.db', 'data/memory/memory.db', // matches `CLAUDE_FLOW_MEMORY_PATH=data/memory`
+    'data/memory.db');
+    for (const dbPath of candidates) {
         if (existsSync(dbPath)) {
             try {
                 const stats = statSync(dbPath);

package/v3/@claude-flow/cli/dist/src/init/helpers-generator.js

@@ -424,8 +424,12 @@ export function generateHookHandler() {
         '  if (stdinData.trim()) {',
         '    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore */ }',
         '  }',
-        '  // Prefer stdin fields, then env, then argv',
-        "  var prompt = hookInput.prompt || hookInput.command || hookInput.toolInput || process.env.PROMPT || process.env.TOOL_INPUT_command || args.join(' ') || '';",
+        '  // Prefer stdin fields, then env, then argv. `hookInput.toolInput` is an',
+        '  // object (e.g. {command:"ls"}); falling back to it directly bound prompt',
+        '  // to the object and tripped .toLowerCase() / .substring() on every Bash',
+        '  // hook (#1944). Pull `.command` off whichever stdin shape Claude Code sent.',
+        '  var toolInputObj = hookInput.toolInput || hookInput.tool_input || {};',
+        "  var prompt = hookInput.prompt || hookInput.command || toolInputObj.command || process.env.PROMPT || process.env.TOOL_INPUT_command || args.join(' ') || '';",
         '',
         'const handlers = {',
         "  'route': () => {",

package/v3/@claude-flow/cli/dist/src/init/settings-generator.js

@@ -154,21 +154,35 @@ export function generateSettings(options) {
  */
 const IS_WINDOWS = process.platform === 'win32';
 /**
- * Build a hook command with reliable $CLAUDE_PROJECT_DIR expansion.
- * Wraps in `sh -c` to guarantee shell expansion on all platforms (macOS zsh,
- * Linux bash). Falls back to "." if CLAUDE_PROJECT_DIR is unset, since
- * Claude Code runs hooks from the project root.
- * On Windows, uses `cmd /c` with %CLAUDE_PROJECT_DIR%.
+ * Build a hook command that resolves to the right helpers dir on every
+ * install layout. `ruflo init` can land helpers either project-locally
+ * (`<project>/.claude/helpers/…`, when run from a project root) or globally
+ * (`$HOME/.claude/helpers/…`, when settings.json gets merged into the
+ * user-level Claude Code config). The earlier `${CLAUDE_PROJECT_DIR:-.}`
+ * form assumed project-local — so any global-install user hit
+ * `MODULE_NOT_FOUND` on every Bash/Edit/Session hook (#1943).
+ *
+ * The fix is a tiny POSIX `sh` probe: try `$CLAUDE_PROJECT_DIR/.claude/...`
+ * first, fall back to `$HOME/.claude/...` if it's missing. Both modes work,
+ * the global install never crashes, and project-local overrides still take
+ * precedence when present. On Windows, the same probe via `cmd /c` (the %~%
+ * fallback uses `IF EXIST`).
  */
 function hookCmd(script, subcommand) {
     if (IS_WINDOWS) {
-        return `cmd /c node %CLAUDE_PROJECT_DIR%/${script} ${subcommand}`.trim();
+        // cmd.exe equivalent of the sh probe below. `IF EXIST` checks the
+        // project-local path; falls back to %USERPROFILE% if missing.
+        return `cmd /c "IF EXIST \"%CLAUDE_PROJECT_DIR%\\${script.replace(/\//g, '\\')}\" (node \"%CLAUDE_PROJECT_DIR%\\${script.replace(/\//g, '\\')}\" ${subcommand}) ELSE (node \"%USERPROFILE%\\${script.replace(/\//g, '\\')}\" ${subcommand})"`;
     }
-    // Use sh -c to ensure $CLAUDE_PROJECT_DIR is expanded by a real shell,
-    // even if Claude Code doesn't invoke hooks through a shell on macOS.
+    // POSIX sh: prefer project-local helpers, fall back to $HOME/.claude/.
+    // The fallback handles `ruflo init`'s global-install path where helpers
+    // live at `$HOME/.claude/helpers/` but Claude Code still sets
+    // `CLAUDE_PROJECT_DIR` to the *project* root (which has no helpers).
     // eslint-disable-next-line no-template-curly-in-string
-    const dir = '${CLAUDE_PROJECT_DIR:-.}';
-    return `sh -c 'exec node "${dir}/${script}" ${subcommand}'`;
+    const projVar = '${CLAUDE_PROJECT_DIR:-.}';
+    // eslint-disable-next-line no-template-curly-in-string
+    const homeVar = '${HOME}';
+    return `sh -c 'D="${projVar}"; [ -f "$D/${script}" ] || D="${homeVar}"; exec node "$D/${script}" ${subcommand}'`;
 }
 /** Shorthand for CJS hook-handler commands */
 function hookHandlerCmd(subcommand) {
@@ -188,11 +202,18 @@ function generateStatusLineConfig(_options) {
     // The script runs after each assistant message (debounced 300ms).
     // NOTE: statusline must NOT use `cmd /c` — Claude Code manages its stdin
     // directly for statusline commands, and `cmd /c` blocks stdin forwarding.
+    //
+    // Same project-local / $HOME fallback as `hookCmd()` (see #1943): the
+    // earlier `${CLAUDE_PROJECT_DIR:-.}` form broke statusline for any
+    // global-install user. Probe project-local first, fall back to $HOME.
+    const script = '.claude/helpers/statusline.cjs';
+    // eslint-disable-next-line no-template-curly-in-string
+    const projVar = '${CLAUDE_PROJECT_DIR:-.}';
     // eslint-disable-next-line no-template-curly-in-string
-    const dir = '${CLAUDE_PROJECT_DIR:-.}';
+    const homeVar = '${HOME}';
     return {
         type: 'command',
-        command: `sh -c 'exec node "${dir}/.claude/helpers/statusline.cjs"'`,
+        command: `sh -c 'D="${projVar}"; [ -f "$D/${script}" ] || D="${homeVar}"; exec node "$D/${script}"'`,
     };
 }
 /**

package/v3/@claude-flow/cli/dist/src/init/statusline-generator.js

@@ -637,23 +637,34 @@ function generateStatusline() {
   const integration = getIntegrationStatus();
   const lines = [];
 
-  // Header
-  // Read version from package.json
+  // Header — read version from the FIRST package.json we find, preferring
+  // the plugin install at ~/.claude/plugins/marketplaces/ruflo/package.json.
+  // The previous list only checked project-local node_modules, so plugin
+  // users saw the hard-coded fallback (V3.5) even on newer alphas (#1951).
   let pkgVersion = '3.6';
   try {
-    const pkgPath = path.join(CWD, 'node_modules', '@claude-flow', 'cli', 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-      if (pkg.version) pkgVersion = pkg.version;
-    } else {
-      // Try npx-installed location
-      const npxPkg = path.join(CWD, 'v3', '@claude-flow', 'cli', 'package.json');
-      if (fs.existsSync(npxPkg)) {
-        const pkg = JSON.parse(fs.readFileSync(npxPkg, 'utf-8'));
-        if (pkg.version) pkgVersion = pkg.version;
-      }
+    const home = require('os').homedir();
+    const pkgPaths = [
+      // 1. The plugin's own root (installed via /plugin install).
+      path.join(home, '.claude', 'plugins', 'marketplaces', 'ruflo', 'package.json'),
+      // 2. Project-local @claude-flow/cli — npm-style install.
+      path.join(CWD, 'node_modules', '@claude-flow', 'cli', 'package.json'),
+      // 3. Project-local ruflo umbrella.
+      path.join(CWD, 'node_modules', 'ruflo', 'package.json'),
+      // 4. Source-checkout location (when developing in this repo).
+      path.join(CWD, 'v3', '@claude-flow', 'cli', 'package.json'),
+    ];
+    for (const p of pkgPaths) {
+      if (!fs.existsSync(p)) continue;
+      try {
+        const pkg = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        if (pkg && typeof pkg.version === 'string' && pkg.version.length > 0) {
+          pkgVersion = pkg.version;
+          break;
+        }
+      } catch { /* malformed package.json — try next */ }
     }
-  } catch { /* use default */ }
+  } catch { /* fall through to the hardcoded default */ }
   let header = c.bold + c.brightPurple + '\\u258A RuFlo V' + pkgVersion + ' ' + c.reset;
   header += (swarm.coordinationActive ? c.brightCyan : c.dim) + '\\u25CF ' + c.brightCyan + git.name + c.reset;
   if (git.gitBranch) {

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.js

@@ -18,26 +18,50 @@
  */
 import * as path from 'path';
 import * as crypto from 'crypto';
+import { createRequire } from 'node:module';
 // ===== Lazy singleton =====
 let registryPromise = null;
 let registryInstance = null;
 let bridgeAvailable = null;
 /**
  * Resolve database path with path traversal protection.
- * Only allows paths within or below the project's .swarm directory,
+ * Only allows paths within or below the project's working directory,
  * or the special ':memory:' path.
+ *
+ * #1945: the previous hard-coded `<cwd>/.swarm/memory.db` default ignored
+ * `CLAUDE_FLOW_MEMORY_PATH` / `claude-flow.config.json#memory.persistPath`
+ * — so users with non-default memory paths had `memory init` write to e.g.
+ * `data/memory/memory.db` while `bridgeStoreEntry()` wrote to
+ * `.swarm/memory.db`. CLI store reported success against the wrong file and
+ * a fresh process reading the configured path saw nothing.
+ *
+ * Use `getMemoryRoot()` (from memory-initializer) so the bridge and the
+ * initializer agree on the same file. Imported via require() to avoid a
+ * circular ESM dep between memory-initializer.ts and memory-bridge.ts.
  */
 function getDbPath(customPath) {
-    const swarmDir = path.resolve(process.cwd(), '.swarm');
+    let defaultDir = path.resolve(process.cwd(), '.swarm');
+    try {
+        // `getMemoryRoot()` honors $CLAUDE_FLOW_MEMORY_PATH, then the
+        // claude-flow.config.json `memory.persistPath`, then defaults to `.swarm`.
+        const cjsRequire = createRequire(import.meta.url);
+        const mod = cjsRequire('./memory-initializer.js');
+        if (typeof mod.getMemoryRoot === 'function') {
+            defaultDir = mod.getMemoryRoot();
+        }
+    }
+    catch {
+        /* memory-initializer not resolvable in this build — keep `.swarm/` default */
+    }
     if (!customPath)
-        return path.join(swarmDir, 'memory.db');
+        return path.join(defaultDir, 'memory.db');
     if (customPath === ':memory:')
         return ':memory:';
     const resolved = path.resolve(customPath);
-    // Ensure the path doesn't escape the working directory
+    // Ensure the path doesn't escape the working directory.
     const cwd = process.cwd();
     if (!resolved.startsWith(cwd)) {
-        return path.join(swarmDir, 'memory.db'); // fallback to safe default
+        return path.join(defaultDir, 'memory.db'); // fallback to safe default
     }
     return resolved;
 }

package/v3/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -866,10 +866,13 @@ INSERT OR REPLACE INTO metadata (key, value) VALUES
   ('temporal_decay', 'enabled'),
   ('hnsw_indexing', 'enabled');
 
--- Create default vector index configuration
+-- Create default vector index configuration. Dimension matches the default
+-- ONNX embedding model (Xenova/all-MiniLM-L6-v2, 384-dim); HNSW rejects
+-- inserts whose dim does not match this row, so a 768 here breaks every
+-- memory_store --vector and memory_search on a fresh install (#1947).
 INSERT OR IGNORE INTO vector_indexes (id, name, dimensions) VALUES
-  ('default', 'default', 768),
-  ('patterns', 'patterns', 768);
+  ('default', 'default', 384),
+  ('patterns', 'patterns', 384);
 `;
 }
 /**

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.27",
+  "version": "3.7.0-alpha.29",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",