@sparkleideas/cli 3.1.0-alpha.64 → 3.5.15-patch.2

package/dist/src/init/executor.js

@@ -5,6 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
 import { dirname } from 'path';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -12,8 +13,8 @@ const __dirname = dirname(__filename);
 import { detectPlatform, DEFAULT_INIT_OPTIONS } from './types.js';
 import { generateSettingsJson, generateSettings } from './settings-generator.js';
 import { generateMCPJson } from './mcp-generator.js';
-import { generateStatuslineScript, generateStatuslineHook } from './statusline-generator.js';
-import { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, } from './helpers-generator.js';
+import { generateStatuslineScript } from './statusline-generator.js';
+import { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHookHandler, generateIntelligenceStub, generateAutoMemoryHook, } from './helpers-generator.js';
 import { generateClaudeMd } from './claudemd-generator.js';
 /**
  * Skills to copy based on configuration
@@ -179,24 +180,6 @@ export async function executeInit(options) {
         if (options.components.helpers) {
             await writeHelpers(targetDir, options, result);
         }
-        // SG-003: If settings will be generated but helpers were skipped,
-        // generate the critical helpers that settings.json hooks reference
-        else if (options.components.settings) {
-            const hDir = path.join(targetDir, '.claude', 'helpers');
-            fs.mkdirSync(hDir, { recursive: true });
-            const criticalForSettings = {
-                'hook-handler.cjs': generateHookHandler(),
-                'auto-memory-hook.mjs': generateAutoMemoryHook(),
-            };
-            for (const [name, content] of Object.entries(criticalForSettings)) {
-                const fp = path.join(hDir, name);
-                if (!fs.existsSync(fp)) {
-                    fs.writeFileSync(fp, content, 'utf-8');
-                    try { fs.chmodSync(fp, '755'); } catch { /* T4: chmod is best-effort */ }
-                    result.created.files.push(`.claude/helpers/${name}`);
-                }
-            }
-        }
         // Generate statusline
         if (options.components.statusline) {
             await writeStatusline(targetDir, options, result);
@@ -234,12 +217,9 @@ function mergeSettingsForUpgrade(existing) {
     // Platform-specific command wrappers
     // Windows: Use PowerShell-compatible commands
     // Mac/Linux: Use bash-compatible commands with 2>/dev/null
-    const teammateIdleCmd = isWindows
-        ? 'npx @sparkleideas/cli@latest hooks teammate-idle --auto-assign true 2>$null; exit 0'
-        : 'npx @sparkleideas/cli@latest hooks teammate-idle --auto-assign true 2>/dev/null || true';
-    const taskCompletedCmd = isWindows
-        ? 'if ($env:TASK_ID) { npx @sparkleideas/cli@latest hooks task-completed --task-id $env:TASK_ID --train-patterns true 2>$null }; exit 0'
-        : '[ -n "$TASK_ID" ] && npx @sparkleideas/cli@latest hooks task-completed --task-id "$TASK_ID" --train-patterns true 2>/dev/null || true';
+    // NOTE: teammateIdleCmd and taskCompletedCmd were removed.
+    // TeammateIdle/TaskCompleted are not valid Claude Code hook events and caused warnings.
+    // Agent Teams hook config lives in claudeFlow.agentTeams.hooks instead.
     // 1. Merge env vars (preserve existing, add new)
     const existingEnv = existing.env || {};
     merged.env = {
@@ -248,41 +228,73 @@ function mergeSettingsForUpgrade(existing) {
         CLAUDE_FLOW_V3_ENABLED: existingEnv.CLAUDE_FLOW_V3_ENABLED || 'true',
         CLAUDE_FLOW_HOOKS_ENABLED: existingEnv.CLAUDE_FLOW_HOOKS_ENABLED || 'true',
     };
-    // 2. Merge hooks (preserve existing, add new Agent Teams hooks)
+    // 2. Merge hooks (preserve existing, add new Agent Teams + auto-memory hooks)
     const existingHooks = existing.hooks || {};
     merged.hooks = { ...existingHooks };
-    // Add TeammateIdle hook if not present
-    if (!existingHooks.TeammateIdle) {
-        merged.hooks.TeammateIdle = [
-            {
-                hooks: [
-                    {
-                        type: 'command',
-                        command: teammateIdleCmd,
-                        timeout: 5000,
-                        continueOnError: true,
-                    },
-                ],
-            },
-        ];
+    // Cross-platform auto-memory hook commands that resolve paths via git root.
+    // Uses node -e with git rev-parse so hooks work regardless of CWD (#1259, #1284).
+    const gitRootResolver = "var c=require('child_process'),p=require('path'),u=require('url'),r;"
+        + "try{r=c.execSync('git rev-parse --show-toplevel',{encoding:'utf8'}).trim()}"
+        + 'catch(e){r=process.cwd()}';
+    const autoMemoryScript = '.claude/helpers/auto-memory-hook.mjs';
+    const autoMemoryImportCmd = `node -e "${gitRootResolver}var f=p.join(r,'${autoMemoryScript}');import(u.pathToFileURL(f).href)" import`;
+    const autoMemorySyncCmd = `node -e "${gitRootResolver}var f=p.join(r,'${autoMemoryScript}');import(u.pathToFileURL(f).href)" sync`;
+    // Add auto-memory import to SessionStart (if not already present)
+    const sessionStartHooks = existingHooks.SessionStart;
+    const hasAutoMemoryImport = sessionStartHooks?.some(group => group.hooks?.some(h => h.command?.includes('auto-memory-hook')));
+    if (!hasAutoMemoryImport) {
+        const startHooks = merged.hooks;
+        if (!startHooks.SessionStart) {
+            startHooks.SessionStart = [{ hooks: [] }];
+        }
+        const startGroup = startHooks.SessionStart[0];
+        if (!startGroup.hooks)
+            startGroup.hooks = [];
+        startGroup.hooks.push({
+            type: 'command',
+            command: autoMemoryImportCmd,
+            timeout: 6000,
+            continueOnError: true,
+        });
     }
-    // Add TaskCompleted hook if not present
-    if (!existingHooks.TaskCompleted) {
-        merged.hooks.TaskCompleted = [
-            {
-                hooks: [
-                    {
-                        type: 'command',
-                        command: taskCompletedCmd,
-                        timeout: 5000,
-                        continueOnError: true,
-                    },
-                ],
-            },
-        ];
+    // Add auto-memory sync to SessionEnd (if not already present)
+    const sessionEndHooks = existingHooks.SessionEnd;
+    const hasAutoMemorySync = sessionEndHooks?.some(group => group.hooks?.some(h => h.command?.includes('auto-memory-hook')));
+    if (!hasAutoMemorySync) {
+        const endHooks = merged.hooks;
+        if (!endHooks.SessionEnd) {
+            endHooks.SessionEnd = [{ hooks: [] }];
+        }
+        const endGroup = endHooks.SessionEnd[0];
+        if (!endGroup.hooks)
+            endGroup.hooks = [];
+        // Insert at beginning so sync runs before other cleanup
+        endGroup.hooks.unshift({
+            type: 'command',
+            command: autoMemorySyncCmd,
+            timeout: 8000,
+            continueOnError: true,
+        });
     }
-    // 3. Merge claudeFlow settings (preserve existing, add agentTeams)
+    // NOTE: TeammateIdle and TaskCompleted are NOT valid Claude Code hook events.
+    // They cause warnings when present in settings.json hooks.
+    // Remove them if they exist from a previous init.
+    delete merged.hooks.TeammateIdle;
+    delete merged.hooks.TaskCompleted;
+    // Their configuration lives in claudeFlow.agentTeams.hooks instead.
+    // 3. Fix statusLine config (remove invalid fields, ensure correct format)
+    // Claude Code only supports: type, command, padding
+    const existingStatusLine = existing.statusLine;
+    if (existingStatusLine) {
+        merged.statusLine = {
+            type: 'command',
+            command: existingStatusLine.command || `node -e "var c=require('child_process'),p=require('path'),r;try{r=c.execSync('git rev-parse --show-toplevel',{encoding:'utf8'}).trim()}catch(e){r=process.cwd()}var s=p.join(r,'.claude/helpers/statusline.cjs');process.argv.splice(1,0,s);require(s)"`,
+            // Remove invalid fields: refreshMs, enabled (not supported by Claude Code)
+        };
+    }
+    // 4. Merge claudeFlow settings (preserve existing, add agentTeams + memory)
     const existingClaudeFlow = existing.claudeFlow || {};
+    const existingMemory = existingClaudeFlow.memory || {};
     merged.claudeFlow = {
         ...existingClaudeFlow,
         version: existingClaudeFlow.version || '3.0.0',
@@ -303,6 +315,12 @@ function mergeSettingsForUpgrade(existing) {
                 taskCompleted: { enabled: true, trainPatterns: true, notifyLead: true },
             },
         },
+        memory: {
+            ...existingMemory,
+            learningBridge: existingMemory.learningBridge ?? { enabled: true },
+            memoryGraph: existingMemory.memoryGraph ?? { enabled: true },
+            agentScopes: existingMemory.agentScopes ?? { enabled: true },
+        },
     };
     return merged;
 }
@@ -335,6 +353,50 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 fs.mkdirSync(fullPath, { recursive: true });
             }
         }
+        // 0. ALWAYS update critical helpers (force overwrite)
+        const sourceHelpersForUpgrade = findSourceHelpersDir();
+        if (sourceHelpersForUpgrade) {
+            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs'];
+            for (const helperName of criticalHelpers) {
+                const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
+                const sourcePath = path.join(sourceHelpersForUpgrade, helperName);
+                if (fs.existsSync(sourcePath)) {
+                    if (fs.existsSync(targetPath)) {
+                        result.updated.push(`.claude/helpers/${helperName}`);
+                    }
+                    else {
+                        result.created.push(`.claude/helpers/${helperName}`);
+                    }
+                    fs.copyFileSync(sourcePath, targetPath);
+                    try {
+                        fs.chmodSync(targetPath, '755');
+                    }
+                    catch { }
+                }
+            }
+        }
+        else {
+            // Source not found (npx with broken paths) — use generated fallbacks
+            const generatedCritical = {
+                'hook-handler.cjs': generateHookHandler(),
+                'intelligence.cjs': generateIntelligenceStub(),
+                'auto-memory-hook.mjs': generateAutoMemoryHook(),
+            };
+            for (const [helperName, content] of Object.entries(generatedCritical)) {
+                const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
+                if (fs.existsSync(targetPath)) {
+                    result.updated.push(`.claude/helpers/${helperName}`);
+                }
+                else {
+                    result.created.push(`.claude/helpers/${helperName}`);
+                }
+                fs.writeFileSync(targetPath, content, 'utf-8');
+                try {
+                    fs.chmodSync(targetPath, '755');
+                }
+                catch { }
+            }
+        }
         // 1. ALWAYS update statusline helper (force overwrite)
         const statuslinePath = path.join(targetDir, '.claude', 'helpers', 'statusline.cjs');
         // Use default options with statusline config
@@ -436,9 +498,12 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                     result.updated.push('.claude/settings.json');
                     result.settingsUpdated = [
                         'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
-                        'hooks.TeammateIdle',
-                        'hooks.TaskCompleted',
+                        'hooks.SessionStart (auto-memory import)',
+                        'hooks.SessionEnd (auto-memory sync)',
+                        'hooks.TeammateIdle (removed — not a valid Claude Code hook)',
+                        'hooks.TaskCompleted (removed — not a valid Claude Code hook)',
                         'claudeFlow.agentTeams',
+                        'claudeFlow.memory (learningBridge, memoryGraph, agentScopes)',
                     ];
                 }
                 catch (settingsError) {
@@ -767,42 +832,51 @@ async function copyAgents(targetDir, options, result) {
     }
 }
 /**
- * Find source helpers directory
+ * Find source helpers directory.
+ * Validates that the directory contains hook-handler.cjs to avoid
+ * returning the target directory or an incomplete source.
  */
 function findSourceHelpersDir(sourceBaseDir) {
     const possiblePaths = [];
+    const SENTINEL_FILE = 'hook-handler.cjs'; // Must exist in valid source
     // If explicit source base directory is provided, check it first
     if (sourceBaseDir) {
         possiblePaths.push(path.join(sourceBaseDir, '.claude', 'helpers'));
     }
-    // IMPORTANT: Check the package's own .claude/helpers directory
-    // This is the primary path when running as an npm package
-    // __dirname is typically /path/to/node_modules/@sparkleideas/cli/dist/src/init
-    // We need to go up 3 levels to reach the package root (dist/src/init -> dist/src -> dist -> root)
+    // Strategy 1: require.resolve to find package root (most reliable for npx)
+    try {
+        const esmRequire = createRequire(import.meta.url);
+        const pkgJsonPath = esmRequire.resolve('@sparkleideas/cli/package.json');
+        const pkgRoot = path.dirname(pkgJsonPath);
+        possiblePaths.push(path.join(pkgRoot, '.claude', 'helpers'));
+    }
+    catch {
+        // Not installed as a package — skip
+    }
+    // Strategy 2: __dirname-based (dist/src/init -> package root)
     const packageRoot = path.resolve(__dirname, '..', '..', '..');
     const packageHelpers = path.join(packageRoot, '.claude', 'helpers');
-    if (fs.existsSync(packageHelpers)) {
-        possiblePaths.unshift(packageHelpers); // Add to beginning (highest priority)
-    }
-    // From dist/src/init -> go up to project root
+    possiblePaths.push(packageHelpers);
+    // Strategy 3: Walk up from __dirname looking for package root
     let currentDir = __dirname;
     for (let i = 0; i < 10; i++) {
         const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir)
+            break; // hit filesystem root
         const helpersPath = path.join(parentDir, '.claude', 'helpers');
-        if (fs.existsSync(helpersPath)) {
-            possiblePaths.push(helpersPath);
-        }
+        possiblePaths.push(helpersPath);
         currentDir = parentDir;
     }
-    // Also check relative to process.cwd() for development
+    // Strategy 4: Check cwd-relative paths (for local dev)
     const cwdBased = [
         path.join(process.cwd(), '.claude', 'helpers'),
         path.join(process.cwd(), '..', '.claude', 'helpers'),
         path.join(process.cwd(), '..', '..', '.claude', 'helpers'),
     ];
     possiblePaths.push(...cwdBased);
+    // Return first path that exists AND contains the sentinel file
     for (const p of possiblePaths) {
-        if (fs.existsSync(p)) {
+        if (fs.existsSync(p) && fs.existsSync(path.join(p, SENTINEL_FILE))) {
             return p;
         }
     }
@@ -849,6 +923,9 @@ async function writeHelpers(targetDir, options, result) {
         'session.js': generateSessionManager(),
         'router.js': generateAgentRouter(),
         'memory.js': generateMemoryHelper(),
+        'hook-handler.cjs': generateHookHandler(),
+        'intelligence.cjs': generateIntelligenceStub(),
+        'auto-memory-hook.mjs': generateAutoMemoryHook(),
     };
     for (const [name, content] of Object.entries(helpers)) {
         const filePath = path.join(helpersDir, name);
@@ -911,7 +988,6 @@ async function writeStatusline(targetDir, options, result) {
         { src: 'statusline.sh', dest: 'statusline.sh', dir: claudeDir },
         { src: 'statusline.mjs', dest: 'statusline.mjs', dir: claudeDir },
     ];
-    let copiedAdvanced = false;
     if (sourceClaudeDir) {
         for (const file of advancedStatuslineFiles) {
             const sourcePath = path.join(sourceClaudeDir, file.src);
@@ -924,7 +1000,6 @@ async function writeStatusline(targetDir, options, result) {
                         fs.chmodSync(destPath, '755');
                     }
                     result.created.files.push(`.claude/${file.dest}`);
-                    copiedAdvanced = true;
                 }
                 else {
                     result.skipped.push(`.claude/${file.dest}`);
@@ -932,24 +1007,16 @@ async function writeStatusline(targetDir, options, result) {
             }
         }
     }
-    // Fall back to generating simple statusline if advanced files not available
-    if (!copiedAdvanced) {
-        const statuslineScript = generateStatuslineScript(options);
-        const statuslineHook = generateStatuslineHook(options);
-        const files = {
-            'statusline.cjs': statuslineScript, // .cjs for ES module project compatibility
-            'statusline-hook.sh': statuslineHook,
-        };
-        for (const [name, content] of Object.entries(files)) {
-            const filePath = path.join(helpersDir, name);
-            if (!fs.existsSync(filePath) || options.force) {
-                fs.writeFileSync(filePath, content, 'utf-8');
-                result.created.files.push(`.claude/helpers/${name}`);
-            }
-            else {
-                result.skipped.push(`.claude/helpers/${name}`);
-            }
-        }
+    // ALWAYS generate statusline.cjs — settings.json references this path
+    // regardless of whether advanced statusline files were also copied.
+    const statuslineScript = generateStatuslineScript(options);
+    const statuslinePath = path.join(helpersDir, 'statusline.cjs');
+    if (!fs.existsSync(statuslinePath) || options.force) {
+        fs.writeFileSync(statuslinePath, statuslineScript, 'utf-8');
+        result.created.files.push('.claude/helpers/statusline.cjs');
+    }
+    else {
+        result.skipped.push('.claude/helpers/statusline.cjs');
     }
 }
 /**
@@ -961,7 +1028,7 @@ async function writeRuntimeConfig(targetDir, options, result) {
         result.skipped.push('.claude-flow/config.yaml');
         return;
     }
-    const config = `# Claude Flow V3 Runtime Configuration
+    const config = `# RuFlo V3 Runtime Configuration
 # Generated: ${new Date().toISOString()}
 
 version: "3.0.0"
@@ -977,6 +1044,21 @@ memory:
   enableHNSW: ${options.runtime.enableHNSW}
   persistPath: .claude-flow/data
   cacheSize: 100
+  # ADR-049: Self-Learning Memory
+  learningBridge:
+    enabled: ${options.runtime.enableLearningBridge ?? options.runtime.enableNeural}
+    sonaMode: balanced
+    confidenceDecayRate: 0.005
+    accessBoostAmount: 0.03
+    consolidationThreshold: 10
+  memoryGraph:
+    enabled: ${options.runtime.enableMemoryGraph ?? true}
+    pageRankDamping: 0.85
+    maxNodes: 5000
+    similarityThreshold: 0.8
+  agentScopes:
+    enabled: ${options.runtime.enableAgentScopes ?? true}
+    defaultScope: project
 
 neural:
   enabled: ${options.runtime.enableNeural}
@@ -1126,7 +1208,7 @@ async function writeCapabilitiesDoc(targetDir, options, result) {
         result.skipped.push('.claude-flow/CAPABILITIES.md');
         return;
     }
-    const capabilities = `# Claude Flow V3 - Complete Capabilities Reference
+    const capabilities = `# RuFlo V3 - Complete Capabilities Reference
 > Generated: ${new Date().toISOString()}
 > Full documentation: https://github.com/ruvnet/claude-flow
 
@@ -1146,7 +1228,7 @@ async function writeCapabilitiesDoc(targetDir, options, result) {
 
 ## Overview
 
-Claude Flow V3 is a domain-driven design architecture for multi-agent AI coordination with:
+RuFlo V3 is a domain-driven design architecture for multi-agent AI coordination with:
 
 - **15-Agent Swarm Coordination** with hierarchical and mesh topologies
 - **HNSW Vector Search** - 150x-12,500x faster pattern retrieval
@@ -1162,6 +1244,9 @@ Claude Flow V3 is a domain-driven design architecture for multi-agent AI coordin
 | Memory Backend | ${options.runtime.memoryBackend} |
 | HNSW Indexing | ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'} |
 | Neural Learning | ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'} |
+| LearningBridge | ${options.runtime.enableLearningBridge ? 'Enabled (SONA + ReasoningBank)' : 'Disabled'} |
+| Knowledge Graph | ${options.runtime.enableMemoryGraph ? 'Enabled (PageRank + Communities)' : 'Disabled'} |
+| Agent Scopes | ${options.runtime.enableAgentScopes ? 'Enabled (project/local/user)' : 'Disabled'} |
 
 ---
 
@@ -1362,6 +1447,25 @@ npx @sparkleideas/cli@latest doctor --fix
 3. **DISTILL** - LoRA learning extraction
 4. **CONSOLIDATE** - EWC++ preservation
 
+### Self-Learning Memory (ADR-049)
+
+| Component | Status | Description |
+|-----------|--------|-------------|
+| **LearningBridge** | ${options.runtime.enableLearningBridge ? '✅ Enabled' : '⏸ Disabled'} | Connects insights to SONA/ReasoningBank neural pipeline |
+| **MemoryGraph** | ${options.runtime.enableMemoryGraph ? '✅ Enabled' : '⏸ Disabled'} | PageRank knowledge graph + community detection |
+| **AgentMemoryScope** | ${options.runtime.enableAgentScopes ? '✅ Enabled' : '⏸ Disabled'} | 3-scope agent memory (project/local/user) |
+
+**LearningBridge** - Insights trigger learning trajectories. Confidence evolves: +0.03 on access, -0.005/hour decay. Consolidation runs the JUDGE/DISTILL/CONSOLIDATE pipeline.
+
+**MemoryGraph** - Builds a knowledge graph from entry references. PageRank identifies influential insights. Communities group related knowledge. Graph-aware ranking blends vector + structural scores.
+
+**AgentMemoryScope** - Maps Claude Code 3-scope directories:
+- \`project\`: \`<gitRoot>/.claude/agent-memory/<agent>/\`
+- \`local\`: \`<gitRoot>/.claude/agent-memory-local/<agent>/\`
+- \`user\`: \`~/.claude/agent-memory/<agent>/\`
+
+High-confidence insights (>0.8) can transfer between agents.
+
 ### Memory Commands
 \`\`\`bash
 # Store pattern
@@ -1428,6 +1532,11 @@ npx @sparkleideas/cli@latest hive-mind consensus --propose "task"
 | MCP Response | <100ms | ✅ Achieved |
 | CLI Startup | <500ms | ✅ Achieved |
 | SONA Adaptation | <0.05ms | 🔄 In Progress |
+| Graph Build (1k) | <200ms | ✅ 2.78ms (71.9x headroom) |
+| PageRank (1k) | <100ms | ✅ 12.21ms (8.2x headroom) |
+| Insight Recording | <5ms/each | ✅ 0.12ms (41x headroom) |
+| Consolidation | <500ms | ✅ 0.26ms (1,955x headroom) |
+| Knowledge Transfer | <100ms | ✅ 1.25ms (80x headroom) |
 
 ---
 
@@ -1436,8 +1545,8 @@ npx @sparkleideas/cli@latest hive-mind consensus --propose "task"
 ### Integrated Packages
 | Package | Version | Purpose |
 |---------|---------|---------|
-| agentic-flow | 2.0.1-alpha | Core coordination |
-| agentdb | 2.0.0-alpha.3.4 | Vector database |
+| agentic-flow | 3.0.0-alpha.1 | Core coordination + ReasoningBank + Router |
+| agentdb | 3.0.0-alpha.10 | Vector database + 8 controllers |
 | @ruvector/attention | 0.1.3 | Flash attention |
 | @ruvector/sona | 0.1.5 | Neural learning |
 
@@ -1622,6 +1731,8 @@ function countEnabledHooks(options) {
         count++;
     if (hooks.stop)
         count++;
+    if (hooks.preCompact)
+        count++;
     if (hooks.notification)
         count++;
     return count;