@claude-flow/cli 3.1.0-alpha.4 → 3.1.0-alpha.40

package/dist/src/init/executor.js

@@ -5,15 +5,16 @@
 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);
 const __dirname = dirname(__filename);
 import { detectPlatform, DEFAULT_INIT_OPTIONS } from './types.js';
-import { generateSettingsJson } from './settings-generator.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
@@ -30,6 +31,7 @@ const SKILLS_MAP = {
         'skill-builder',
     ],
     browser: ['browser'], // agent-browser integration
+    dualMode: ['dual-mode'], // Claude Code + Codex hybrid execution
     agentdb: [
         'agentdb-advanced',
         'agentdb-learning',
@@ -87,6 +89,7 @@ const AGENTS_MAP = {
     sparc: ['sparc'],
     swarm: ['swarm'],
     browser: ['browser'], // agent-browser integration
+    dualMode: ['dual-mode'], // Claude Code + Codex hybrid execution
     // V3-specific agents
     v3: ['v3'],
     optimization: ['optimization'],
@@ -202,17 +205,155 @@ export async function executeInit(options) {
     }
     return result;
 }
+/**
+ * Merge new settings into existing settings.json
+ * Preserves user customizations while adding new features like Agent Teams
+ * Uses platform-specific commands for Mac, Linux, and Windows
+ */
+function mergeSettingsForUpgrade(existing) {
+    const merged = { ...existing };
+    const platform = detectPlatform();
+    const isWindows = platform.os === 'windows';
+    // Platform-specific command wrappers
+    // Windows: Use PowerShell-compatible commands
+    // Mac/Linux: Use bash-compatible commands with 2>/dev/null
+    const teammateIdleCmd = isWindows
+        ? 'npx @claude-flow/cli@latest hooks teammate-idle --auto-assign true 2>$null; exit 0'
+        : 'npx @claude-flow/cli@latest hooks teammate-idle --auto-assign true 2>/dev/null || true';
+    const taskCompletedCmd = isWindows
+        ? 'if ($env:TASK_ID) { npx @claude-flow/cli@latest hooks task-completed --task-id $env:TASK_ID --train-patterns true 2>$null }; exit 0'
+        : '[ -n "$TASK_ID" ] && npx @claude-flow/cli@latest hooks task-completed --task-id "$TASK_ID" --train-patterns true 2>/dev/null || true';
+    // 1. Merge env vars (preserve existing, add new)
+    const existingEnv = existing.env || {};
+    merged.env = {
+        ...existingEnv,
+        CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+        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 + auto-memory hooks)
+    const existingHooks = existing.hooks || {};
+    merged.hooks = { ...existingHooks };
+    // Platform-specific auto-memory hook commands
+    const autoMemoryImportCmd = isWindows
+        ? 'node .claude/helpers/auto-memory-hook.mjs import 2>$null; exit 0'
+        : 'node .claude/helpers/auto-memory-hook.mjs import 2>/dev/null || true';
+    const autoMemorySyncCmd = isWindows
+        ? 'node .claude/helpers/auto-memory-hook.mjs sync 2>$null; exit 0'
+        : 'node .claude/helpers/auto-memory-hook.mjs sync 2>/dev/null || true';
+    // 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 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,
+        });
+    }
+    // Add TeammateIdle hook if not present
+    if (!existingHooks.TeammateIdle) {
+        merged.hooks.TeammateIdle = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: teammateIdleCmd,
+                        timeout: 5000,
+                        continueOnError: true,
+                    },
+                ],
+            },
+        ];
+    }
+    // Add TaskCompleted hook if not present
+    if (!existingHooks.TaskCompleted) {
+        merged.hooks.TaskCompleted = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: taskCompletedCmd,
+                        timeout: 5000,
+                        continueOnError: true,
+                    },
+                ],
+            },
+        ];
+    }
+    // 3. 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',
+        enabled: existingClaudeFlow.enabled !== false,
+        agentTeams: {
+            enabled: true,
+            teammateMode: 'auto',
+            taskListEnabled: true,
+            mailboxEnabled: true,
+            coordination: {
+                autoAssignOnIdle: true,
+                trainPatternsOnComplete: true,
+                notifyLeadOnComplete: true,
+                sharedMemoryNamespace: 'agent-teams',
+            },
+            hooks: {
+                teammateIdle: { enabled: true, autoAssign: true, checkTaskList: true },
+                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;
+}
 /**
  * Execute upgrade - updates helpers and creates missing metrics without losing data
  * This is safe for existing users who want the latest statusline fixes
+ * @param targetDir - Target directory
+ * @param upgradeSettings - If true, merge new settings into existing settings.json
  */
-export async function executeUpgrade(targetDir) {
+export async function executeUpgrade(targetDir, upgradeSettings = false) {
     const result = {
         success: true,
         updated: [],
         created: [],
         preserved: [],
         errors: [],
+        settingsUpdated: [],
     };
     try {
         // Ensure required directories exist
@@ -228,6 +369,50 @@ export async function executeUpgrade(targetDir) {
                 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
@@ -318,6 +503,37 @@ export async function executeUpgrade(targetDir) {
         else {
             result.preserved.push('.claude-flow/security/audit-status.json');
         }
+        // 3. Merge settings if requested
+        if (upgradeSettings) {
+            const settingsPath = path.join(targetDir, '.claude', 'settings.json');
+            if (fs.existsSync(settingsPath)) {
+                try {
+                    const existingSettings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                    const mergedSettings = mergeSettingsForUpgrade(existingSettings);
+                    fs.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2), 'utf-8');
+                    result.updated.push('.claude/settings.json');
+                    result.settingsUpdated = [
+                        'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
+                        'hooks.SessionStart (auto-memory import)',
+                        'hooks.SessionEnd (auto-memory sync)',
+                        'hooks.TeammateIdle',
+                        'hooks.TaskCompleted',
+                        'claudeFlow.agentTeams',
+                        'claudeFlow.memory (learningBridge, memoryGraph, agentScopes)',
+                    ];
+                }
+                catch (settingsError) {
+                    result.errors.push(`Settings merge failed: ${settingsError instanceof Error ? settingsError.message : String(settingsError)}`);
+                }
+            }
+            else {
+                // Create new settings.json with defaults
+                const defaultSettings = generateSettings(DEFAULT_INIT_OPTIONS);
+                fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2), 'utf-8');
+                result.created.push('.claude/settings.json');
+                result.settingsUpdated = ['Created new settings.json with Agent Teams'];
+            }
+        }
     }
     catch (error) {
         result.success = false;
@@ -328,10 +544,12 @@ export async function executeUpgrade(targetDir) {
 /**
  * Execute upgrade with --add-missing flag
  * Adds any new skills, agents, and commands that don't exist yet
+ * @param targetDir - Target directory
+ * @param upgradeSettings - If true, merge new settings into existing settings.json
  */
-export async function executeUpgradeWithMissing(targetDir) {
-    // First do the normal upgrade
-    const result = await executeUpgrade(targetDir);
+export async function executeUpgradeWithMissing(targetDir, upgradeSettings = false) {
+    // First do the normal upgrade (pass through upgradeSettings)
+    const result = await executeUpgrade(targetDir, upgradeSettings);
     if (!result.success) {
         return result;
     }
@@ -486,6 +704,8 @@ async function copySkills(targetDir, options, result) {
             skillsToCopy.push(...SKILLS_MAP.browser);
         if (skillsConfig.v3)
             skillsToCopy.push(...SKILLS_MAP.v3);
+        if (skillsConfig.dualMode)
+            skillsToCopy.push(...SKILLS_MAP.dualMode);
     }
     // Find source skills directory
     const sourceSkillsDir = findSourceDir('skills', options.sourceBaseDir);
@@ -598,6 +818,9 @@ async function copyAgents(targetDir, options, result) {
             agentsToCopy.push(...(AGENTS_MAP.optimization || []));
         if (agentsConfig.testing)
             agentsToCopy.push(...(AGENTS_MAP.testing || []));
+        // Dual-mode agents (Claude Code + Codex hybrid)
+        if (agentsConfig.dualMode)
+            agentsToCopy.push(...(AGENTS_MAP.dualMode || []));
     }
     // Find source agents directory
     const sourceAgentsDir = findSourceDir('agents', options.sourceBaseDir);
@@ -625,42 +848,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/@claude-flow/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('@claude-flow/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;
         }
     }
@@ -707,6 +939,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);
@@ -769,7 +1004,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);
@@ -782,7 +1016,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}`);
@@ -790,24 +1023,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');
     }
 }
 /**
@@ -835,6 +1060,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}
@@ -1020,6 +1260,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'} |
 
 ---
 
@@ -1220,6 +1463,25 @@ npx @claude-flow/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
@@ -1286,6 +1548,11 @@ npx @claude-flow/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) |
 
 ---
 
@@ -1480,6 +1747,8 @@ function countEnabledHooks(options) {
         count++;
     if (hooks.stop)
         count++;
+    if (hooks.preCompact)
+        count++;
     if (hooks.notification)
         count++;
     return count;