moflo 4.0.0

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

@@ -0,0 +1,113 @@
+/**
+ * V3 CLI Commands Index
+ * Central registry for all CLI commands
+ *
+ * NOTE: All commands are synchronously imported at module load time (lines below).
+ * The commandLoaders/loadCommand infrastructure provides an async fallback for
+ * commands looked up via getCommandAsync() but does NOT reduce startup time since
+ * all modules are already imported synchronously for the commands array and
+ * commandsByCategory exports.
+ */
+import type { Command } from '../types.js';
+export { initCommand } from './init.js';
+export { startCommand } from './start.js';
+export { statusCommand } from './status.js';
+export { taskCommand } from './task.js';
+export { sessionCommand } from './session.js';
+export { agentCommand } from './agent.js';
+export { swarmCommand } from './swarm.js';
+export { memoryCommand } from './memory.js';
+export { mcpCommand } from './mcp.js';
+export { hooksCommand } from './hooks.js';
+export { daemonCommand } from './daemon.js';
+export { doctorCommand } from './doctor.js';
+export { embeddingsCommand } from './embeddings.js';
+export { neuralCommand } from './neural.js';
+export { performanceCommand } from './performance.js';
+export { securityCommand } from './security.js';
+export { ruvectorCommand } from './ruvector/index.js';
+export { hiveMindCommand } from './hive-mind.js';
+export { guidanceCommand } from './guidance.js';
+export { applianceCommand } from './appliance.js';
+export declare function getConfigCommand(): Promise<Command | undefined>;
+export declare function getMigrateCommand(): Promise<Command | undefined>;
+export declare function getWorkflowCommand(): Promise<Command | undefined>;
+export declare function getHiveMindCommand(): Promise<Command | undefined>;
+export declare function getProcessCommand(): Promise<Command | undefined>;
+export declare function getTaskCommand(): Promise<Command | undefined>;
+export declare function getSessionCommand(): Promise<Command | undefined>;
+export declare function getNeuralCommand(): Promise<Command | undefined>;
+export declare function getSecurityCommand(): Promise<Command | undefined>;
+export declare function getPerformanceCommand(): Promise<Command | undefined>;
+export declare function getProvidersCommand(): Promise<Command | undefined>;
+export declare function getPluginsCommand(): Promise<Command | undefined>;
+export declare function getDeploymentCommand(): Promise<Command | undefined>;
+export declare function getClaimsCommand(): Promise<Command | undefined>;
+export declare function getEmbeddingsCommand(): Promise<Command | undefined>;
+export declare function getCompletionsCommand(): Promise<Command | undefined>;
+export declare function getAnalyzeCommand(): Promise<Command | undefined>;
+export declare function getRouteCommand(): Promise<Command | undefined>;
+export declare function getProgressCommand(): Promise<Command | undefined>;
+export declare function getIssuesCommand(): Promise<Command | undefined>;
+export declare function getRuvectorCommand(): Promise<Command | undefined>;
+export declare function getGuidanceCommand(): Promise<Command | undefined>;
+export declare function getApplianceCommand(): Promise<Command | undefined>;
+/**
+ * Core commands loaded synchronously (available immediately)
+ * Advanced commands loaded on-demand for faster startup
+ */
+export declare const commands: Command[];
+/**
+ * Commands organized by category for help display
+ */
+export declare const commandsByCategory: {
+    primary: Command[];
+    advanced: Command[];
+    utility: Command[];
+    analysis: Command[];
+    management: Command[];
+};
+/**
+ * Command registry map for quick lookup
+ * Supports both sync (core commands) and async (lazy-loaded) commands
+ */
+export declare const commandRegistry: Map<string, Command>;
+/**
+ * Get command by name (sync for core commands, returns undefined for lazy commands)
+ * Use getCommandAsync for lazy-loaded commands
+ */
+export declare function getCommand(name: string): Command | undefined;
+/**
+ * Get command by name (async - supports lazy loading)
+ */
+export declare function getCommandAsync(name: string): Promise<Command | undefined>;
+/**
+ * Check if command exists (sync check for core commands)
+ */
+export declare function hasCommand(name: string): boolean;
+/**
+ * Get all command names (including aliases and lazy-loadable)
+ */
+export declare function getCommandNames(): string[];
+/**
+ * Get all unique commands (excluding aliases)
+ */
+export declare function getUniqueCommands(): Command[];
+/**
+ * Load all commands (populates lazy-loaded commands)
+ * Use this when you need all commands available synchronously
+ */
+export declare function loadAllCommands(): Promise<Command[]>;
+/**
+ * Setup commands in a CLI instance
+ */
+export declare function setupCommands(cli: {
+    command: (cmd: Command) => void;
+}): void;
+/**
+ * Setup all commands including lazy-loaded (async)
+ */
+export declare function setupAllCommands(cli: {
+    command: (cmd: Command) => void;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,372 @@
+/**
+ * V3 CLI Commands Index
+ * Central registry for all CLI commands
+ *
+ * NOTE: All commands are synchronously imported at module load time (lines below).
+ * The commandLoaders/loadCommand infrastructure provides an async fallback for
+ * commands looked up via getCommandAsync() but does NOT reduce startup time since
+ * all modules are already imported synchronously for the commands array and
+ * commandsByCategory exports.
+ */
+/**
+ * Command loaders - commands are only imported when needed
+ * This reduces initial bundle parse time by ~200ms
+ */
+const commandLoaders = {
+    // P1 Core Commands (frequently used - load first)
+    init: () => import('./init.js'),
+    start: () => import('./start.js'),
+    status: () => import('./status.js'),
+    task: () => import('./task.js'),
+    session: () => import('./session.js'),
+    // Original Commands
+    agent: () => import('./agent.js'),
+    swarm: () => import('./swarm.js'),
+    memory: () => import('./memory.js'),
+    mcp: () => import('./mcp.js'),
+    config: () => import('./config.js'),
+    migrate: () => import('./migrate.js'),
+    hooks: () => import('./hooks.js'),
+    workflow: () => import('./workflow.js'),
+    'hive-mind': () => import('./hive-mind.js'),
+    process: () => import('./process.js'),
+    daemon: () => import('./daemon.js'),
+    // V3 Advanced Commands (less frequently used - lazy load)
+    neural: () => import('./neural.js'),
+    security: () => import('./security.js'),
+    performance: () => import('./performance.js'),
+    providers: () => import('./providers.js'),
+    plugins: () => import('./plugins.js'),
+    deployment: () => import('./deployment.js'),
+    claims: () => import('./claims.js'),
+    embeddings: () => import('./embeddings.js'),
+    // P0 Commands
+    completions: () => import('./completions.js'),
+    doctor: () => import('./doctor.js'),
+    // Analysis Commands
+    analyze: () => import('./analyze.js'),
+    // Q-Learning Routing Commands
+    route: () => import('./route.js'),
+    // Progress Commands
+    progress: () => import('./progress.js'),
+    // Issue Claims Commands (ADR-016)
+    issues: () => import('./issues.js'),
+    // Auto-update System (ADR-025)
+    update: () => import('./update.js'),
+    // RuVector PostgreSQL Bridge
+    ruvector: () => import('./ruvector/index.js'),
+    // Benchmark Suite (Pre-training, Neural, Memory)
+    benchmark: () => import('./benchmark.js'),
+    // Guidance Control Plane
+    guidance: () => import('./guidance.js'),
+    // RVFA Appliance Management
+    appliance: () => import('./appliance.js'),
+    // MoFlo Workflow Gates
+    gate: () => import('./gate.js'),
+    // Feature Orchestrator
+    orc: () => import('./orc.js'),
+};
+// Cache for loaded commands
+const loadedCommands = new Map();
+/**
+ * Load a command lazily
+ */
+async function loadCommand(name) {
+    if (loadedCommands.has(name)) {
+        return loadedCommands.get(name);
+    }
+    const loader = commandLoaders[name];
+    if (!loader)
+        return undefined;
+    try {
+        const module = await loader();
+        // Try to find the command export (either default or named)
+        const command = (module.default || module[`${name}Command`] || Object.values(module).find((v) => typeof v === 'object' && v !== null && 'name' in v && 'description' in v));
+        if (command) {
+            loadedCommands.set(name, command);
+            return command;
+        }
+    }
+    catch (error) {
+        // Silently fail for missing optional commands
+        if (process.env.DEBUG) {
+            console.error(`Failed to load command ${name}:`, error);
+        }
+    }
+    return undefined;
+}
+// =============================================================================
+// Synchronous Imports for Core Commands (needed immediately at startup)
+// These are the most commonly used commands that need instant access
+// =============================================================================
+import { initCommand } from './init.js';
+import { startCommand } from './start.js';
+import { statusCommand } from './status.js';
+import { taskCommand } from './task.js';
+import { sessionCommand } from './session.js';
+import { agentCommand } from './agent.js';
+import { swarmCommand } from './swarm.js';
+import { memoryCommand } from './memory.js';
+import { mcpCommand } from './mcp.js';
+import { hooksCommand } from './hooks.js';
+import { daemonCommand } from './daemon.js';
+import { doctorCommand } from './doctor.js';
+import { embeddingsCommand } from './embeddings.js';
+import { neuralCommand } from './neural.js';
+import { performanceCommand } from './performance.js';
+import { securityCommand } from './security.js';
+import { ruvectorCommand } from './ruvector/index.js';
+import { hiveMindCommand } from './hive-mind.js';
+// Additional commands for categorized help display
+import { configCommand } from './config.js';
+import { completionsCommand } from './completions.js';
+import { migrateCommand } from './migrate.js';
+import { workflowCommand } from './workflow.js';
+import { analyzeCommand } from './analyze.js';
+import { routeCommand } from './route.js';
+import { progressCommand } from './progress.js';
+import { providersCommand } from './providers.js';
+import { pluginsCommand } from './plugins.js';
+import { deploymentCommand } from './deployment.js';
+import { claimsCommand } from './claims.js';
+import { issuesCommand } from './issues.js';
+import updateCommand from './update.js';
+import { processCommand } from './process.js';
+import { guidanceCommand } from './guidance.js';
+import { applianceCommand } from './appliance.js';
+// Pre-populate cache with core commands
+loadedCommands.set('init', initCommand);
+loadedCommands.set('start', startCommand);
+loadedCommands.set('status', statusCommand);
+loadedCommands.set('task', taskCommand);
+loadedCommands.set('session', sessionCommand);
+loadedCommands.set('agent', agentCommand);
+loadedCommands.set('swarm', swarmCommand);
+loadedCommands.set('memory', memoryCommand);
+loadedCommands.set('mcp', mcpCommand);
+loadedCommands.set('hooks', hooksCommand);
+loadedCommands.set('daemon', daemonCommand);
+loadedCommands.set('doctor', doctorCommand);
+loadedCommands.set('embeddings', embeddingsCommand);
+loadedCommands.set('neural', neuralCommand);
+loadedCommands.set('performance', performanceCommand);
+loadedCommands.set('security', securityCommand);
+loadedCommands.set('ruvector', ruvectorCommand);
+loadedCommands.set('hive-mind', hiveMindCommand);
+loadedCommands.set('guidance', guidanceCommand);
+// =============================================================================
+// Exports (maintain backwards compatibility)
+// =============================================================================
+// Export synchronously loaded commands
+export { initCommand } from './init.js';
+export { startCommand } from './start.js';
+export { statusCommand } from './status.js';
+export { taskCommand } from './task.js';
+export { sessionCommand } from './session.js';
+export { agentCommand } from './agent.js';
+export { swarmCommand } from './swarm.js';
+export { memoryCommand } from './memory.js';
+export { mcpCommand } from './mcp.js';
+export { hooksCommand } from './hooks.js';
+export { daemonCommand } from './daemon.js';
+export { doctorCommand } from './doctor.js';
+export { embeddingsCommand } from './embeddings.js';
+export { neuralCommand } from './neural.js';
+export { performanceCommand } from './performance.js';
+export { securityCommand } from './security.js';
+export { ruvectorCommand } from './ruvector/index.js';
+export { hiveMindCommand } from './hive-mind.js';
+export { guidanceCommand } from './guidance.js';
+export { applianceCommand } from './appliance.js';
+// Lazy-loaded command re-exports (for backwards compatibility, but async-only)
+export async function getConfigCommand() { return loadCommand('config'); }
+export async function getMigrateCommand() { return loadCommand('migrate'); }
+export async function getWorkflowCommand() { return loadCommand('workflow'); }
+export async function getHiveMindCommand() { return loadCommand('hive-mind'); }
+export async function getProcessCommand() { return loadCommand('process'); }
+export async function getTaskCommand() { return loadCommand('task'); }
+export async function getSessionCommand() { return loadCommand('session'); }
+export async function getNeuralCommand() { return loadCommand('neural'); }
+export async function getSecurityCommand() { return loadCommand('security'); }
+export async function getPerformanceCommand() { return loadCommand('performance'); }
+export async function getProvidersCommand() { return loadCommand('providers'); }
+export async function getPluginsCommand() { return loadCommand('plugins'); }
+export async function getDeploymentCommand() { return loadCommand('deployment'); }
+export async function getClaimsCommand() { return loadCommand('claims'); }
+export async function getEmbeddingsCommand() { return loadCommand('embeddings'); }
+export async function getCompletionsCommand() { return loadCommand('completions'); }
+export async function getAnalyzeCommand() { return loadCommand('analyze'); }
+export async function getRouteCommand() { return loadCommand('route'); }
+export async function getProgressCommand() { return loadCommand('progress'); }
+export async function getIssuesCommand() { return loadCommand('issues'); }
+export async function getRuvectorCommand() { return loadCommand('ruvector'); }
+export async function getGuidanceCommand() { return loadCommand('guidance'); }
+export async function getApplianceCommand() { return loadCommand('appliance'); }
+/**
+ * Core commands loaded synchronously (available immediately)
+ * Advanced commands loaded on-demand for faster startup
+ */
+export const commands = [
+    // Core commands (synchronously loaded)
+    initCommand,
+    startCommand,
+    statusCommand,
+    taskCommand,
+    sessionCommand,
+    agentCommand,
+    swarmCommand,
+    memoryCommand,
+    mcpCommand,
+    hooksCommand,
+    daemonCommand,
+    doctorCommand,
+    embeddingsCommand,
+    neuralCommand,
+    performanceCommand,
+    securityCommand,
+    ruvectorCommand,
+    hiveMindCommand,
+    guidanceCommand,
+];
+/**
+ * Commands organized by category for help display
+ */
+export const commandsByCategory = {
+    primary: [
+        initCommand,
+        startCommand,
+        statusCommand,
+        agentCommand,
+        swarmCommand,
+        memoryCommand,
+        taskCommand,
+        sessionCommand,
+        mcpCommand,
+        hooksCommand,
+    ],
+    advanced: [
+        neuralCommand,
+        securityCommand,
+        performanceCommand,
+        embeddingsCommand,
+        hiveMindCommand,
+        ruvectorCommand,
+        guidanceCommand,
+    ],
+    utility: [
+        configCommand,
+        doctorCommand,
+        daemonCommand,
+        completionsCommand,
+        migrateCommand,
+        workflowCommand,
+    ],
+    analysis: [
+        analyzeCommand,
+        routeCommand,
+        progressCommand,
+    ],
+    management: [
+        providersCommand,
+        pluginsCommand,
+        deploymentCommand,
+        claimsCommand,
+        issuesCommand,
+        updateCommand,
+        processCommand,
+        applianceCommand,
+    ],
+};
+/**
+ * Command registry map for quick lookup
+ * Supports both sync (core commands) and async (lazy-loaded) commands
+ */
+export const commandRegistry = new Map();
+// Register core commands and their aliases
+for (const cmd of commands) {
+    commandRegistry.set(cmd.name, cmd);
+    if (cmd.aliases) {
+        for (const alias of cmd.aliases) {
+            commandRegistry.set(alias, cmd);
+        }
+    }
+}
+/**
+ * Get command by name (sync for core commands, returns undefined for lazy commands)
+ * Use getCommandAsync for lazy-loaded commands
+ */
+export function getCommand(name) {
+    return loadedCommands.get(name) || commandRegistry.get(name);
+}
+/**
+ * Get command by name (async - supports lazy loading)
+ */
+export async function getCommandAsync(name) {
+    // Check already-loaded commands first
+    const cached = loadedCommands.get(name);
+    if (cached)
+        return cached;
+    // Check sync registry
+    const synced = commandRegistry.get(name);
+    if (synced)
+        return synced;
+    // Try lazy loading
+    return loadCommand(name);
+}
+/**
+ * Check if command exists (sync check for core commands)
+ */
+export function hasCommand(name) {
+    return loadedCommands.has(name) || commandRegistry.has(name) || name in commandLoaders;
+}
+/**
+ * Get all command names (including aliases and lazy-loadable)
+ */
+export function getCommandNames() {
+    const names = new Set([
+        ...Array.from(commandRegistry.keys()),
+        ...Array.from(loadedCommands.keys()),
+        ...Object.keys(commandLoaders),
+    ]);
+    return Array.from(names);
+}
+/**
+ * Get all unique commands (excluding aliases)
+ */
+export function getUniqueCommands() {
+    return commands.filter(cmd => !cmd.hidden);
+}
+/**
+ * Load all commands (populates lazy-loaded commands)
+ * Use this when you need all commands available synchronously
+ */
+export async function loadAllCommands() {
+    const allCommands = [...commands];
+    for (const name of Object.keys(commandLoaders)) {
+        if (!loadedCommands.has(name)) {
+            const cmd = await loadCommand(name);
+            if (cmd && !allCommands.includes(cmd)) {
+                allCommands.push(cmd);
+            }
+        }
+    }
+    return allCommands;
+}
+/**
+ * Setup commands in a CLI instance
+ */
+export function setupCommands(cli) {
+    for (const cmd of commands) {
+        cli.command(cmd);
+    }
+}
+/**
+ * Setup all commands including lazy-loaded (async)
+ */
+export async function setupAllCommands(cli) {
+    const allCommands = await loadAllCommands();
+    for (const cmd of allCommands) {
+        cli.command(cmd);
+    }
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * V3 CLI Init Command
+ * Comprehensive initialization for Claude Flow with Claude Code integration
+ */
+import type { Command } from '../types.js';
+export declare const initCommand: Command;
+export default initCommand;
+//# sourceMappingURL=init.d.ts.map