moflo 4.0.0

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

@@ -0,0 +1,287 @@
+/**
+ * V3 Init System Types
+ * Configuration options for initializing Claude Code integration
+ */
+/**
+ * Components that can be initialized
+ */
+export interface InitComponents {
+    /** Create .claude/settings.json with hooks */
+    settings: boolean;
+    /** Copy skills to .claude/skills/ */
+    skills: boolean;
+    /** Copy commands to .claude/commands/ */
+    commands: boolean;
+    /** Copy agents to .claude/agents/ */
+    agents: boolean;
+    /** Create helper scripts in .claude/helpers/ */
+    helpers: boolean;
+    /** Configure statusline */
+    statusline: boolean;
+    /** Create MCP configuration */
+    mcp: boolean;
+    /** Create .claude-flow/ directory (V3 runtime) */
+    runtime: boolean;
+    /** Create CLAUDE.md with swarm guidance */
+    claudeMd: boolean;
+}
+/**
+ * Hook configuration options
+ * Valid hook types: PreToolUse, PostToolUse, Notification, UserPromptSubmit,
+ * SessionStart, SessionEnd, Stop, SubagentStop, PreCompact
+ */
+export interface HooksConfig {
+    /** Enable PreToolUse hooks */
+    preToolUse: boolean;
+    /** Enable PostToolUse hooks */
+    postToolUse: boolean;
+    /** Enable UserPromptSubmit for routing */
+    userPromptSubmit: boolean;
+    /** Enable SessionStart hooks */
+    sessionStart: boolean;
+    /** Enable Stop hooks */
+    stop: boolean;
+    /** Enable PreCompact hooks (context preservation before compaction) */
+    preCompact: boolean;
+    /** Enable Notification hooks */
+    notification: boolean;
+    /** Hook timeout in milliseconds */
+    timeout: number;
+    /** Continue on hook error */
+    continueOnError: boolean;
+}
+/**
+ * Skills configuration
+ */
+export interface SkillsConfig {
+    /** Include core skills (swarm, memory, sparc) */
+    core: boolean;
+    /** Include AgentDB skills */
+    agentdb: boolean;
+    /** Include GitHub integration skills */
+    github: boolean;
+    /** Include Flow Nexus skills */
+    flowNexus: boolean;
+    /** Include browser automation skills (agent-browser) */
+    browser: boolean;
+    /** Include V3 implementation skills */
+    v3: boolean;
+    /** Include dual-mode skills (Claude Code + Codex hybrid) */
+    dualMode: boolean;
+    /** Include all available skills */
+    all: boolean;
+}
+/**
+ * Commands configuration
+ */
+export interface CommandsConfig {
+    /** Include core commands */
+    core: boolean;
+    /** Include analysis commands */
+    analysis: boolean;
+    /** Include automation commands */
+    automation: boolean;
+    /** Include github commands */
+    github: boolean;
+    /** Include hooks commands */
+    hooks: boolean;
+    /** Include monitoring commands */
+    monitoring: boolean;
+    /** Include optimization commands */
+    optimization: boolean;
+    /** Include SPARC commands */
+    sparc: boolean;
+    /** Include all commands */
+    all: boolean;
+}
+/**
+ * Agents configuration
+ */
+export interface AgentsConfig {
+    /** Include core agents (coder, tester, reviewer) */
+    core: boolean;
+    /** Include consensus agents */
+    consensus: boolean;
+    /** Include GitHub agents */
+    github: boolean;
+    /** Include hive-mind agents */
+    hiveMind: boolean;
+    /** Include SPARC agents */
+    sparc: boolean;
+    /** Include swarm coordinators */
+    swarm: boolean;
+    /** Include browser automation agents (agent-browser) */
+    browser: boolean;
+    /** Include V3-specific agents (security, memory, performance, etc.) */
+    v3: boolean;
+    /** Include optimization agents */
+    optimization: boolean;
+    /** Include testing agents */
+    testing: boolean;
+    /** Include dual-mode agents (Claude Code + Codex hybrid) */
+    dualMode: boolean;
+    /** Include all agents */
+    all: boolean;
+}
+/**
+ * Statusline configuration
+ */
+export interface StatuslineConfig {
+    /** Enable statusline */
+    enabled: boolean;
+    /** Show V3 progress */
+    showProgress: boolean;
+    /** Show security status */
+    showSecurity: boolean;
+    /** Show swarm activity */
+    showSwarm: boolean;
+    /** Show hooks metrics */
+    showHooks: boolean;
+    /** Show performance targets */
+    showPerformance: boolean;
+    /** Refresh interval in milliseconds */
+    refreshInterval: number;
+}
+/**
+ * MCP configuration
+ */
+export interface MCPConfig {
+    /** Include claude-flow MCP server */
+    claudeFlow: boolean;
+    /** Include ruv-swarm MCP server */
+    ruvSwarm: boolean;
+    /** Include flow-nexus MCP server */
+    flowNexus: boolean;
+    /** Auto-start MCP server */
+    autoStart: boolean;
+    /** Server port */
+    port: number;
+}
+/**
+ * Runtime configuration (.claude-flow/)
+ */
+export interface RuntimeConfig {
+    /** Swarm topology */
+    topology: 'mesh' | 'hierarchical' | 'hierarchical-mesh' | 'adaptive';
+    /** Maximum agents */
+    maxAgents: number;
+    /** Memory backend */
+    memoryBackend: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
+    /** Enable HNSW indexing */
+    enableHNSW: boolean;
+    /** Enable neural learning */
+    enableNeural: boolean;
+    /** Enable LearningBridge (ADR-049) - connects insights to SONA/ReasoningBank */
+    enableLearningBridge?: boolean;
+    /** Enable MemoryGraph (ADR-049) - PageRank knowledge graph */
+    enableMemoryGraph?: boolean;
+    /** Enable AgentMemoryScope (ADR-049) - 3-scope agent memory */
+    enableAgentScopes?: boolean;
+    /** CLAUDE.md template variant */
+    claudeMdTemplate?: ClaudeMdTemplate;
+}
+/** Template variants for generated CLAUDE.md files */
+export type ClaudeMdTemplate = 'minimal' | 'standard' | 'full' | 'security' | 'performance' | 'solo';
+/**
+ * Embeddings configuration
+ */
+export interface EmbeddingsConfig {
+    /** Enable embedding subsystem */
+    enabled: boolean;
+    /** ONNX model ID */
+    model: 'all-MiniLM-L6-v2' | 'all-mpnet-base-v2' | 'bge-small-en-v1.5' | string;
+    /** Enable hyperbolic (Poincaré ball) embeddings */
+    hyperbolic: boolean;
+    /** Poincaré ball curvature (negative value, typically -1) */
+    curvature: number;
+    /** Pre-download model during init */
+    predownload: boolean;
+    /** LRU cache size (number of embeddings) */
+    cacheSize: number;
+    /** Enable neural substrate integration */
+    neuralSubstrate: boolean;
+}
+/**
+ * Detected platform information
+ */
+export interface PlatformInfo {
+    /** Operating system */
+    os: 'windows' | 'darwin' | 'linux';
+    /** Architecture */
+    arch: 'x64' | 'arm64' | 'arm' | 'ia32';
+    /** Node.js version */
+    nodeVersion: string;
+    /** Shell type */
+    shell: 'powershell' | 'cmd' | 'bash' | 'zsh' | 'sh';
+    /** Home directory */
+    homeDir: string;
+    /** Config directory (platform-specific) */
+    configDir: string;
+}
+/**
+ * Detect current platform
+ */
+export declare function detectPlatform(): PlatformInfo;
+/**
+ * Complete init options
+ */
+export interface InitOptions {
+    /** Target directory */
+    targetDir: string;
+    /** Source base directory for skills/commands/agents (optional) */
+    sourceBaseDir?: string;
+    /** Force overwrite existing files */
+    force: boolean;
+    /** Run in interactive mode */
+    interactive: boolean;
+    /** Components to initialize */
+    components: InitComponents;
+    /** Hooks configuration */
+    hooks: HooksConfig;
+    /** Skills configuration */
+    skills: SkillsConfig;
+    /** Commands configuration */
+    commands: CommandsConfig;
+    /** Agents configuration */
+    agents: AgentsConfig;
+    /** Statusline configuration */
+    statusline: StatuslineConfig;
+    /** MCP configuration */
+    mcp: MCPConfig;
+    /** Runtime configuration */
+    runtime: RuntimeConfig;
+    /** Embeddings configuration */
+    embeddings: EmbeddingsConfig;
+}
+/**
+ * Default init options - full V3 setup
+ */
+export declare const DEFAULT_INIT_OPTIONS: InitOptions;
+/**
+ * Minimal init options
+ */
+export declare const MINIMAL_INIT_OPTIONS: InitOptions;
+/**
+ * Full init options (everything enabled)
+ */
+export declare const FULL_INIT_OPTIONS: InitOptions;
+/**
+ * Init result
+ */
+export interface InitResult {
+    success: boolean;
+    platform: PlatformInfo;
+    created: {
+        directories: string[];
+        files: string[];
+    };
+    skipped: string[];
+    errors: string[];
+    summary: {
+        skillsCount: number;
+        commandsCount: number;
+        agentsCount: number;
+        hooksEnabled: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,259 @@
+/**
+ * V3 Init System Types
+ * Configuration options for initializing Claude Code integration
+ */
+import os from 'os';
+import path from 'path';
+/**
+ * Detect current platform
+ */
+export function detectPlatform() {
+    const platform = os.platform();
+    const arch = os.arch();
+    const homeDir = os.homedir();
+    let osType;
+    let shell;
+    let configDir;
+    switch (platform) {
+        case 'win32':
+            osType = 'windows';
+            shell = process.env.PSModulePath ? 'powershell' : 'cmd';
+            configDir = process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
+            break;
+        case 'darwin':
+            osType = 'darwin';
+            shell = process.env.SHELL?.includes('zsh') ? 'zsh' : 'bash';
+            configDir = path.join(homeDir, 'Library', 'Application Support');
+            break;
+        default:
+            osType = 'linux';
+            shell = process.env.SHELL?.includes('zsh') ? 'zsh' : (process.env.SHELL?.includes('bash') ? 'bash' : 'sh');
+            configDir = process.env.XDG_CONFIG_HOME || path.join(homeDir, '.config');
+    }
+    return {
+        os: osType,
+        arch: arch,
+        nodeVersion: process.version,
+        shell,
+        homeDir,
+        configDir,
+    };
+}
+/**
+ * Default init options - full V3 setup
+ */
+export const DEFAULT_INIT_OPTIONS = {
+    targetDir: process.cwd(),
+    force: false,
+    interactive: true,
+    components: {
+        settings: true,
+        skills: true,
+        commands: true,
+        agents: true,
+        helpers: true,
+        statusline: true,
+        mcp: true,
+        runtime: true,
+        claudeMd: true,
+    },
+    hooks: {
+        preToolUse: true,
+        postToolUse: true,
+        userPromptSubmit: true,
+        sessionStart: true,
+        stop: true,
+        preCompact: true,
+        notification: true,
+        timeout: 5000,
+        continueOnError: true,
+    },
+    skills: {
+        core: true,
+        agentdb: true,
+        github: true,
+        flowNexus: false,
+        browser: true,
+        v3: true,
+        dualMode: false, // Optional: enable with --dual flag
+        all: false,
+    },
+    commands: {
+        core: true,
+        analysis: true,
+        automation: true,
+        github: true,
+        hooks: true,
+        monitoring: true,
+        optimization: true,
+        sparc: true,
+        all: false,
+    },
+    agents: {
+        core: true,
+        consensus: true,
+        github: true,
+        hiveMind: true,
+        sparc: true,
+        swarm: true,
+        browser: true,
+        v3: true,
+        optimization: true,
+        testing: true,
+        dualMode: false, // Optional: enable with --dual flag
+        all: true,
+    },
+    statusline: {
+        enabled: true,
+        showProgress: true,
+        showSecurity: true,
+        showSwarm: true,
+        showHooks: true,
+        showPerformance: true,
+        refreshInterval: 5000,
+    },
+    mcp: {
+        claudeFlow: true,
+        ruvSwarm: false,
+        flowNexus: false,
+        autoStart: false,
+        port: 3000,
+    },
+    runtime: {
+        topology: 'hierarchical-mesh',
+        maxAgents: 15,
+        memoryBackend: 'hybrid',
+        enableHNSW: true,
+        enableNeural: true,
+        enableLearningBridge: true,
+        enableMemoryGraph: true,
+        enableAgentScopes: true,
+    },
+    embeddings: {
+        enabled: true,
+        model: 'all-MiniLM-L6-v2',
+        hyperbolic: true,
+        curvature: -1.0,
+        predownload: false, // Don't auto-download to speed up init
+        cacheSize: 256,
+        neuralSubstrate: true,
+    },
+};
+/**
+ * Minimal init options
+ */
+export const MINIMAL_INIT_OPTIONS = {
+    ...DEFAULT_INIT_OPTIONS,
+    components: {
+        settings: true,
+        skills: true,
+        commands: false,
+        agents: false,
+        helpers: false,
+        statusline: false,
+        mcp: true,
+        runtime: true,
+        claudeMd: true,
+    },
+    hooks: {
+        ...DEFAULT_INIT_OPTIONS.hooks,
+        userPromptSubmit: false,
+        stop: false,
+        notification: false,
+    },
+    skills: {
+        core: true,
+        agentdb: false,
+        github: false,
+        flowNexus: false,
+        browser: false,
+        v3: false,
+        dualMode: false,
+        all: false,
+    },
+    agents: {
+        core: true,
+        consensus: false,
+        github: false,
+        hiveMind: false,
+        sparc: false,
+        swarm: false,
+        browser: false,
+        v3: false,
+        optimization: false,
+        testing: false,
+        dualMode: false,
+        all: false,
+    },
+    runtime: {
+        topology: 'mesh',
+        maxAgents: 5,
+        memoryBackend: 'memory',
+        enableHNSW: false,
+        enableNeural: false,
+        enableLearningBridge: false,
+        enableMemoryGraph: false,
+        enableAgentScopes: false,
+    },
+    embeddings: {
+        enabled: false,
+        model: 'all-MiniLM-L6-v2',
+        hyperbolic: false,
+        curvature: -1.0,
+        predownload: false,
+        cacheSize: 128,
+        neuralSubstrate: false,
+    },
+};
+/**
+ * Full init options (everything enabled)
+ */
+export const FULL_INIT_OPTIONS = {
+    ...DEFAULT_INIT_OPTIONS,
+    components: {
+        settings: true,
+        skills: true,
+        commands: true,
+        agents: true,
+        helpers: true,
+        statusline: true,
+        mcp: true,
+        runtime: true,
+        claudeMd: true,
+    },
+    skills: {
+        core: true,
+        agentdb: true,
+        github: true,
+        flowNexus: true,
+        browser: true,
+        v3: true,
+        dualMode: true, // Include in full init
+        all: true,
+    },
+    commands: {
+        ...DEFAULT_INIT_OPTIONS.commands,
+        all: true,
+    },
+    agents: {
+        ...DEFAULT_INIT_OPTIONS.agents,
+        all: true,
+    },
+    mcp: {
+        claudeFlow: true,
+        ruvSwarm: true,
+        flowNexus: true,
+        autoStart: false,
+        port: 3000,
+    },
+    embeddings: {
+        enabled: true,
+        model: 'all-MiniLM-L6-v2',
+        hyperbolic: true,
+        curvature: -1.0,
+        predownload: true, // Pre-download for full init
+        cacheSize: 256,
+        neuralSubstrate: true,
+    },
+};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,92 @@
+/**
+ * V3 CLI MCP Client
+ *
+ * Thin wrapper for calling MCP tools from CLI commands.
+ * Implements ADR-005: MCP-First API Design - CLI as thin wrapper around MCP tools
+ *
+ * This provides a simple interface for CLI commands to call MCP tools without
+ * containing hardcoded business logic. All business logic lives in MCP tool handlers.
+ */
+import type { MCPTool } from './mcp-tools/types.js';
+/**
+ * MCP Client Error
+ */
+export declare class MCPClientError extends Error {
+    toolName: string;
+    cause?: Error | undefined;
+    constructor(message: string, toolName: string, cause?: Error | undefined);
+}
+/**
+ * Call an MCP tool by name with input parameters
+ *
+ * @param toolName - Name of the MCP tool (e.g., 'agent_spawn', 'swarm_init')
+ * @param input - Input parameters for the tool
+ * @param context - Optional tool context
+ * @returns Promise resolving to tool result
+ * @throws {MCPClientError} If tool not found or execution fails
+ *
+ * @example
+ * ```typescript
+ * // Spawn an agent
+ * const result = await callMCPTool('agent_spawn', {
+ *   agentType: 'coder',
+ *   priority: 'normal'
+ * });
+ *
+ * // Initialize swarm
+ * const swarm = await callMCPTool('swarm_init', {
+ *   topology: 'hierarchical-mesh',
+ *   maxAgents: 15
+ * });
+ * ```
+ */
+export declare function callMCPTool<T = unknown>(toolName: string, input?: Record<string, unknown>, context?: Record<string, unknown>): Promise<T>;
+/**
+ * Get tool metadata by name
+ *
+ * @param toolName - Name of the MCP tool
+ * @returns Tool metadata or undefined if not found
+ */
+export declare function getToolMetadata(toolName: string): Omit<MCPTool, 'handler'> | undefined;
+/**
+ * List all available MCP tools
+ *
+ * @param category - Optional category filter
+ * @returns Array of tool metadata
+ */
+export declare function listMCPTools(category?: string): Array<Omit<MCPTool, 'handler'>>;
+/**
+ * Check if an MCP tool exists
+ *
+ * @param toolName - Name of the MCP tool
+ * @returns True if tool exists
+ */
+export declare function hasTool(toolName: string): boolean;
+/**
+ * Get all tool categories
+ *
+ * @returns Array of unique categories
+ */
+export declare function getToolCategories(): string[];
+/**
+ * Validate tool input against schema
+ *
+ * @param toolName - Name of the MCP tool
+ * @param input - Input to validate
+ * @returns Validation result with errors if any
+ */
+export declare function validateToolInput(toolName: string, input: Record<string, unknown>): {
+    valid: boolean;
+    errors?: string[];
+};
+declare const _default: {
+    callMCPTool: typeof callMCPTool;
+    getToolMetadata: typeof getToolMetadata;
+    listMCPTools: typeof listMCPTools;
+    hasTool: typeof hasTool;
+    getToolCategories: typeof getToolCategories;
+    validateToolInput: typeof validateToolInput;
+    MCPClientError: typeof MCPClientError;
+};
+export default _default;
+//# sourceMappingURL=mcp-client.d.ts.map