@cloudpftc/opencode-orchestrator 3.5.15

package/v3/@claude-flow/cli/dist/src/init/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * V3 Init Module
+ * Comprehensive initialization system for Claude Code integration
+ */
+export { type InitOptions, type InitComponents, type InitResult, type HooksConfig, type SkillsConfig, type CommandsConfig, type AgentsConfig, type StatuslineConfig, type MCPConfig, type RuntimeConfig, type EmbeddingsConfig, type PlatformInfo, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, detectPlatform, } from './types.js';
+export { generateSettings, generateSettingsJson, } from './settings-generator.js';
+export { generateMCPConfig, generateMCPJson, generateMCPCommands, } from './mcp-generator.js';
+export { generateStatuslineScript, generateStatuslineHook, } from './statusline-generator.js';
+export { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHelpers, generateWindowsDaemonManager, generateWindowsBatchWrapper, generateCrossPlatformSessionManager, } from './helpers-generator.js';
+export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
+export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+export type { UpgradeResult } from './executor.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * V3 Init Module
+ * Comprehensive initialization system for Claude Code integration
+ */
+// Types
+export { DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, detectPlatform, } from './types.js';
+// Generators
+export { generateSettings, generateSettingsJson, } from './settings-generator.js';
+export { generateMCPConfig, generateMCPJson, generateMCPCommands, } from './mcp-generator.js';
+export { generateStatuslineScript, generateStatuslineHook, } from './statusline-generator.js';
+export { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHelpers, generateWindowsDaemonManager, generateWindowsBatchWrapper, generateCrossPlatformSessionManager, } from './helpers-generator.js';
+export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
+// Main executor
+export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+//# sourceMappingURL=index.js.map

package/v3/@claude-flow/cli/dist/src/init/mcp-generator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MCP Configuration Generator
+ * Creates .mcp.json for Claude Code and OpenCode MCP server integration
+ * Handles cross-platform compatibility (Windows requires cmd /c wrapper)
+ */
+import type { InitOptions } from './types.js';
+/**
+ * Generate MCP configuration
+ */
+export declare function generateMCPConfig(options: InitOptions): object;
+/**
+ * Generate .mcp.json as formatted string
+ */
+export declare function generateMCPJson(options: InitOptions): string;
+/**
+ * Generate MCP server add commands for manual setup
+ */
+export declare function generateMCPCommands(options: InitOptions): string[];
+/**
+ * Generate OpenCode MCP server add commands
+ * OpenCode uses the same MCP protocol but with 'opencode' CLI
+ */
+export declare function generateOpenCodeMCPCommands(options: InitOptions): string[];
+/**
+ * Get platform-specific setup instructions
+ */
+export declare function getPlatformInstructions(): {
+    platform: string;
+    note: string;
+};
+//# sourceMappingURL=mcp-generator.d.ts.map

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

@@ -0,0 +1,147 @@
+/**
+ * MCP Configuration Generator
+ * Creates .mcp.json for Claude Code and OpenCode MCP server integration
+ * Handles cross-platform compatibility (Windows requires cmd /c wrapper)
+ */
+/**
+ * Check if running on Windows
+ */
+function isWindows() {
+    return process.platform === 'win32';
+}
+/**
+ * Generate platform-specific MCP server entry
+ * - Windows: uses 'cmd /c npx' directly
+ * - Unix: uses 'npx' directly (simple, reliable)
+ */
+function createMCPServerEntry(npxArgs, env, additionalProps = {}) {
+    if (isWindows()) {
+        return {
+            command: 'cmd',
+            args: ['/c', 'npx', '-y', ...npxArgs],
+            env,
+            ...additionalProps,
+        };
+    }
+    // Unix: direct npx invocation — simple and reliable
+    return {
+        command: 'npx',
+        args: ['-y', ...npxArgs],
+        env,
+        ...additionalProps,
+    };
+}
+/**
+ * Generate MCP configuration
+ */
+export function generateMCPConfig(options) {
+    const config = options.mcp;
+    const mcpServers = {};
+    const npmEnv = {
+        npm_config_update_notifier: 'false',
+    };
+    // Claude Flow MCP server (core)
+    if (config.claudeFlow) {
+        mcpServers['claude-flow'] = createMCPServerEntry(['@claude-flow/cli@latest', 'mcp', 'start'], {
+            ...npmEnv,
+            CLAUDE_FLOW_MODE: 'v3',
+            CLAUDE_FLOW_HOOKS_ENABLED: 'true',
+            CLAUDE_FLOW_TOPOLOGY: options.runtime.topology,
+            CLAUDE_FLOW_MAX_AGENTS: String(options.runtime.maxAgents),
+            CLAUDE_FLOW_MEMORY_BACKEND: options.runtime.memoryBackend,
+        }, { autoStart: config.autoStart });
+    }
+    // Ruv-Swarm MCP server (enhanced coordination)
+    if (config.ruvSwarm) {
+        mcpServers['ruv-swarm'] = createMCPServerEntry(['ruv-swarm', 'mcp', 'start'], { ...npmEnv }, { optional: true });
+    }
+    // Flow Nexus MCP server (cloud features)
+    if (config.flowNexus) {
+        mcpServers['flow-nexus'] = createMCPServerEntry(['flow-nexus@latest', 'mcp', 'start'], { ...npmEnv }, { optional: true, requiresAuth: true });
+    }
+    return { mcpServers };
+}
+/**
+ * Generate .mcp.json as formatted string
+ */
+export function generateMCPJson(options) {
+    const config = generateMCPConfig(options);
+    return JSON.stringify(config, null, 2);
+}
+/**
+ * Generate MCP server add commands for manual setup
+ */
+export function generateMCPCommands(options) {
+    const commands = [];
+    const config = options.mcp;
+    if (isWindows()) {
+        if (config.claudeFlow) {
+            commands.push('claude mcp add claude-flow -- cmd /c npx -y @claude-flow/cli@latest mcp start');
+        }
+        if (config.ruvSwarm) {
+            commands.push('claude mcp add ruv-swarm -- cmd /c npx -y ruv-swarm mcp start');
+        }
+        if (config.flowNexus) {
+            commands.push('claude mcp add flow-nexus -- cmd /c npx -y flow-nexus@latest mcp start');
+        }
+    }
+    else {
+        if (config.claudeFlow) {
+            commands.push("claude mcp add claude-flow -- npx -y @claude-flow/cli@latest mcp start");
+        }
+        if (config.ruvSwarm) {
+            commands.push("claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start");
+        }
+        if (config.flowNexus) {
+            commands.push("claude mcp add flow-nexus -- npx -y flow-nexus@latest mcp start");
+        }
+    }
+    return commands;
+}
+/**
+ * Generate OpenCode MCP server add commands
+ * OpenCode uses the same MCP protocol but with 'opencode' CLI
+ */
+export function generateOpenCodeMCPCommands(options) {
+    const commands = [];
+    const config = options.mcp;
+    if (isWindows()) {
+        if (config.claudeFlow) {
+            commands.push('opencode mcp add claude-flow -- cmd /c npx -y @claude-flow/cli@latest mcp start');
+        }
+        if (config.ruvSwarm) {
+            commands.push('opencode mcp add ruv-swarm -- cmd /c npx -y ruv-swarm mcp start');
+        }
+        if (config.flowNexus) {
+            commands.push('opencode mcp add flow-nexus -- cmd /c npx -y flow-nexus@latest mcp start');
+        }
+    }
+    else {
+        if (config.claudeFlow) {
+            commands.push("opencode mcp add claude-flow -- npx -y @claude-flow/cli@latest mcp start");
+        }
+        if (config.ruvSwarm) {
+            commands.push("opencode mcp add ruv-swarm -- npx -y ruv-swarm mcp start");
+        }
+        if (config.flowNexus) {
+            commands.push("opencode mcp add flow-nexus -- npx -y flow-nexus@latest mcp start");
+        }
+    }
+    return commands;
+}
+/**
+ * Get platform-specific setup instructions
+ */
+export function getPlatformInstructions() {
+    if (isWindows()) {
+        return {
+            platform: 'Windows',
+            note: 'MCP configuration uses cmd /c wrapper for npx compatibility.',
+        };
+    }
+    return {
+        platform: process.platform === 'darwin' ? 'macOS' : 'Linux',
+        note: 'MCP configuration uses npx directly.',
+    };
+}
+//# sourceMappingURL=mcp-generator.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Settings.json Generator
+ * Creates .claude/settings.json with V3-optimized hook configurations
+ */
+import type { InitOptions } from './types.js';
+/**
+ * Generate the complete settings.json content
+ */
+export declare function generateSettings(options: InitOptions): object;
+/**
+ * Generate settings.json as formatted string
+ */
+export declare function generateSettingsJson(options: InitOptions): string;
+//# sourceMappingURL=settings-generator.d.ts.map

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

@@ -0,0 +1,399 @@
+/**
+ * Settings.json Generator
+ * Creates .claude/settings.json with V3-optimized hook configurations
+ */
+import { detectPlatform } from './types.js';
+/**
+ * Generate the complete settings.json content
+ */
+export function generateSettings(options) {
+    const settings = {};
+    // Add hooks if enabled
+    if (options.components.settings) {
+        settings.hooks = generateHooksConfig(options.hooks);
+    }
+    // Add statusLine configuration if enabled
+    if (options.statusline.enabled) {
+        settings.statusLine = generateStatusLineConfig(options);
+    }
+    // Add permissions
+    settings.permissions = {
+        allow: [
+            'Bash(npx @claude-flow*)',
+            'Bash(npx claude-flow*)',
+            'Bash(node .claude/*)',
+            'mcp__claude-flow__:*',
+        ],
+        deny: [
+            'Read(./.env)',
+            'Read(./.env.*)',
+        ],
+    };
+    // Add claude-flow attribution for git commits and PRs
+    settings.attribution = {
+        commit: 'Co-Authored-By: claude-flow <ruv@ruv.net>',
+        pr: '🤖 Generated with [claude-flow](https://github.com/ruvnet/claude-flow)',
+    };
+    // Note: Claude Code expects 'model' to be a string, not an object
+    // Model preferences are stored in claudeFlow settings instead
+    // settings.model = 'claude-sonnet-4-5-20250929'; // Uncomment if you want to set a default model
+    // Add Agent Teams configuration (experimental feature)
+    settings.env = {
+        // Enable Claude Code Agent Teams for multi-agent coordination
+        CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+        // Claude Flow specific environment
+        CLAUDE_FLOW_V3_ENABLED: 'true',
+        CLAUDE_FLOW_HOOKS_ENABLED: 'true',
+    };
+    // Detect platform for platform-aware configuration
+    const platform = detectPlatform();
+    // Add V3-specific settings
+    settings.claudeFlow = {
+        version: '3.0.0',
+        enabled: true,
+        platform: {
+            os: platform.os,
+            arch: platform.arch,
+            shell: platform.shell,
+        },
+        modelPreferences: {
+            default: 'claude-opus-4-6',
+            routing: 'claude-haiku-4-5-20251001',
+        },
+        agentTeams: {
+            enabled: true,
+            teammateMode: 'auto', // 'auto' | 'in-process' | 'tmux'
+            taskListEnabled: true,
+            mailboxEnabled: true,
+            coordination: {
+                autoAssignOnIdle: true, // Auto-assign pending tasks when teammate is idle
+                trainPatternsOnComplete: true, // Train neural patterns when tasks complete
+                notifyLeadOnComplete: true, // Notify team lead when tasks complete
+                sharedMemoryNamespace: 'agent-teams', // Memory namespace for team coordination
+            },
+            hooks: {
+                teammateIdle: {
+                    enabled: true,
+                    autoAssign: true,
+                    checkTaskList: true,
+                },
+                taskCompleted: {
+                    enabled: true,
+                    trainPatterns: true,
+                    notifyLead: true,
+                },
+            },
+        },
+        swarm: {
+            topology: options.runtime.topology,
+            maxAgents: options.runtime.maxAgents,
+        },
+        memory: {
+            backend: options.runtime.memoryBackend,
+            enableHNSW: options.runtime.enableHNSW,
+            learningBridge: { enabled: options.runtime.enableLearningBridge ?? true },
+            memoryGraph: { enabled: options.runtime.enableMemoryGraph ?? true },
+            agentScopes: { enabled: options.runtime.enableAgentScopes ?? true },
+        },
+        neural: {
+            enabled: options.runtime.enableNeural,
+        },
+        daemon: {
+            autoStart: true,
+            workers: [
+                'map', // Codebase mapping
+                'audit', // Security auditing (critical priority)
+                'optimize', // Performance optimization (high priority)
+                'consolidate', // Memory consolidation
+                'testgaps', // Test coverage gaps
+                'ultralearn', // Deep knowledge acquisition
+                'deepdive', // Deep code analysis
+                'document', // Auto-documentation for ADRs
+                'refactor', // Refactoring suggestions (DDD alignment)
+                'benchmark', // Performance benchmarking
+            ],
+            schedules: {
+                audit: { interval: '1h', priority: 'critical' },
+                optimize: { interval: '30m', priority: 'high' },
+                consolidate: { interval: '2h', priority: 'low' },
+                document: { interval: '1h', priority: 'normal', triggers: ['adr-update', 'api-change'] },
+                deepdive: { interval: '4h', priority: 'normal', triggers: ['complex-change'] },
+                ultralearn: { interval: '1h', priority: 'normal' },
+            },
+        },
+        learning: {
+            enabled: true,
+            autoTrain: true,
+            patterns: ['coordination', 'optimization', 'prediction'],
+            retention: {
+                shortTerm: '24h',
+                longTerm: '30d',
+            },
+        },
+        adr: {
+            autoGenerate: true,
+            directory: '/docs/adr',
+            template: 'madr',
+        },
+        ddd: {
+            trackDomains: true,
+            validateBoundedContexts: true,
+            directory: '/docs/ddd',
+        },
+        security: {
+            autoScan: true,
+            scanOnEdit: true,
+            cveCheck: true,
+            threatModel: true,
+        },
+    };
+    return settings;
+}
+/**
+ * Detect if we're on Windows for platform-aware hook commands.
+ */
+const IS_WINDOWS = process.platform === 'win32';
+/**
+ * Build a cross-platform hook command.
+ * On Windows, wraps with `cmd /c` to avoid PowerShell stdin/process issues
+ * that cause "UserPromptSubmit hook error" in Claude Code.
+ */
+function hookCmd(script, subcommand) {
+    const cmd = `node ${script} ${subcommand}`.trim();
+    return IS_WINDOWS ? `cmd /c ${cmd}` : cmd;
+}
+/**
+ * Build a cross-platform hook command for ESM scripts (.mjs).
+ */
+function hookCmdEsm(script, subcommand) {
+    const cmd = `node ${script} ${subcommand}`.trim();
+    return IS_WINDOWS ? `cmd /c ${cmd}` : cmd;
+}
+/** Shorthand for CJS hook-handler commands */
+function hookHandlerCmd(subcommand) {
+    return hookCmd('"$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs"', subcommand);
+}
+/** Shorthand for ESM auto-memory-hook commands */
+function autoMemoryCmd(subcommand) {
+    return hookCmdEsm('"$CLAUDE_PROJECT_DIR/.claude/helpers/auto-memory-hook.mjs"', subcommand);
+}
+/**
+ * Generate statusLine configuration for Claude Code
+ * Uses local helper script for cross-platform compatibility (no npx cold-start)
+ */
+function generateStatusLineConfig(_options) {
+    // Claude Code pipes JSON session data to the script via stdin.
+    // Valid fields: type, command, padding (optional).
+    // 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.
+    return {
+        type: 'command',
+        command: `node "$CLAUDE_PROJECT_DIR/.claude/helpers/statusline.cjs"`,
+    };
+}
+/**
+ * Generate hooks configuration
+ * Uses local hook-handler.cjs for cross-platform compatibility.
+ * All hooks invoke scripts directly via `node <script> <subcommand>`,
+ * working identically on Windows, macOS, and Linux.
+ */
+function generateHooksConfig(config) {
+    const hooks = {};
+    // Node.js scripts handle errors internally via try/catch.
+    // No shell-level error suppression needed (2>/dev/null || true breaks Windows).
+    // PreToolUse — validate commands and edits before execution
+    if (config.preToolUse) {
+        hooks.PreToolUse = [
+            {
+                matcher: 'Bash',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('pre-bash'),
+                        timeout: config.timeout,
+                    },
+                ],
+            },
+            {
+                matcher: 'Write|Edit|MultiEdit',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('pre-edit'),
+                        timeout: config.timeout,
+                    },
+                ],
+            },
+        ];
+    }
+    // PostToolUse — record edits and commands for session metrics / learning
+    if (config.postToolUse) {
+        hooks.PostToolUse = [
+            {
+                matcher: 'Write|Edit|MultiEdit',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('post-edit'),
+                        timeout: 10000,
+                    },
+                ],
+            },
+            {
+                matcher: 'Bash',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('post-bash'),
+                        timeout: config.timeout,
+                    },
+                ],
+            },
+        ];
+    }
+    // UserPromptSubmit — intelligent task routing
+    if (config.userPromptSubmit) {
+        hooks.UserPromptSubmit = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('route'),
+                        timeout: 10000,
+                    },
+                ],
+            },
+        ];
+    }
+    // SessionStart — restore session state + import auto memory
+    if (config.sessionStart) {
+        hooks.SessionStart = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('session-restore'),
+                        timeout: 15000,
+                    },
+                    {
+                        type: 'command',
+                        command: autoMemoryCmd('import'),
+                        timeout: 8000,
+                    },
+                ],
+            },
+        ];
+    }
+    // SessionEnd — persist session state
+    if (config.sessionStart) {
+        hooks.SessionEnd = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('session-end'),
+                        timeout: 10000,
+                    },
+                ],
+            },
+        ];
+    }
+    // Stop — sync auto memory on exit
+    if (config.stop) {
+        hooks.Stop = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: autoMemoryCmd('sync'),
+                        timeout: 10000,
+                    },
+                ],
+            },
+        ];
+    }
+    // PreCompact — preserve context before compaction
+    if (config.preCompact) {
+        hooks.PreCompact = [
+            {
+                matcher: 'manual',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('compact-manual'),
+                    },
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('session-end'),
+                        timeout: 5000,
+                    },
+                ],
+            },
+            {
+                matcher: 'auto',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('compact-auto'),
+                    },
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('session-end'),
+                        timeout: 6000,
+                    },
+                ],
+            },
+        ];
+    }
+    // SubagentStart — status update when a sub-agent is spawned
+    hooks.SubagentStart = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: hookHandlerCmd('status'),
+                    timeout: 3000,
+                },
+            ],
+        },
+    ];
+    // SubagentStop — track agent completion for metrics
+    // NOTE: The valid event is "SubagentStop" (not "SubagentEnd")
+    hooks.SubagentStop = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: hookHandlerCmd('post-task'),
+                    timeout: 5000,
+                },
+            ],
+        },
+    ];
+    // Notification — capture Claude Code notifications for logging
+    if (config.notification) {
+        hooks.Notification = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('notify'),
+                        timeout: 3000,
+                    },
+                ],
+            },
+        ];
+    }
+    // NOTE: TeammateIdle and TaskCompleted are NOT valid Claude Code hook events.
+    // Their configuration lives in claudeFlow.agentTeams.hooks instead (see generateSettings).
+    return hooks;
+}
+/**
+ * Generate settings.json as formatted string
+ */
+export function generateSettingsJson(options) {
+    const settings = generateSettings(options);
+    return JSON.stringify(settings, null, 2);
+}
+//# sourceMappingURL=settings-generator.js.map

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

@@ -0,0 +1,28 @@
+/**
+ * Statusline Configuration Generator (Optimized)
+ * Creates fast, reliable statusline for V3 progress display
+ *
+ * Performance:
+ * - Single combined git execSync call (not 8+ separate ones)
+ * - process.memoryUsage() instead of ps aux
+ * - No recursive test file content reading
+ * - Shared settings cache
+ * - Strict 2s timeouts on all shell calls
+ */
+import type { InitOptions } from './types.js';
+/**
+ * Generate optimized statusline script
+ * Output format:
+ * ▊ RuFlo V3 ● user  │  ⎇ branch  │  Opus 4.6
+ * ─────────────────────────────────────────────────────
+ * 🏗️  DDD Domains    [●●○○○]  2/5    ⚡ HNSW 150x
+ * 🤖 Swarm  ◉ [ 5/15]  👥 2    🪝 10/17    🟢 CVE 3/3    💾 4MB    🧠  63%
+ * 🔧 Architecture    ADRs ●71%  │  DDD ● 13%  │  Security ●CLEAN
+ * 📊 AgentDB    Vectors ●3104⚡  │  Size 216KB  │  Tests ●6 (~24 cases)  │  MCP ●1/1
+ */
+export declare function generateStatuslineScript(options: InitOptions): string;
+/**
+ * Generate statusline hook for shell integration
+ */
+export declare function generateStatuslineHook(options: InitOptions): string;
+//# sourceMappingURL=statusline-generator.d.ts.map