@monoes/monomindcli 1.10.54 → 1.10.56

package/.claude/skills/cli-modernization/SKILL.md

@@ -1,950 +0,0 @@
----
-name: cli-modernization
-description: "CLI modernization and hooks system enhancement for monomind. Implements interactive prompts, command decomposition, enhanced hooks integration, and intelligent workflow automation."
-triggers:
-  - modernize CLI
-  - CLI refactor
-  - interactive CLI
-  - add interactive prompts
-  - decompose index.ts
-  - command file too large
-  - CLI hooks integration
-  - CLI performance
----
-
-# CLI Modernization
-
-## What This Skill Does
-
-Modernizes monomind CLI with interactive prompts, intelligent command decomposition, enhanced hooks integration, performance optimization, and comprehensive workflow automation capabilities.
-
-## Quick Start
-
-```bash
-# Initialize CLI modernization analysis
-Task("CLI architecture", "Analyze current CLI structure and identify optimization opportunities", "cli-hooks-developer")
-
-# Modernization implementation (parallel)
-Task("Command decomposition", "Break down large CLI files into focused modules", "cli-hooks-developer")
-Task("Interactive prompts", "Implement intelligent interactive CLI experience", "cli-hooks-developer")
-Task("Hooks enhancement", "Deep integrate hooks with CLI lifecycle", "cli-hooks-developer")
-```
-
-## CLI Architecture Modernization
-
-### Current State Analysis
-
-```
-Current CLI Issues:
-├── index.ts: 108KB monolithic file
-├── enterprise.ts: 68KB feature module
-├── Limited interactivity: Basic command parsing
-├── Hooks integration: Basic pre/post execution
-└── No intelligent workflows: Manual command chaining
-
-Target Architecture:
-├── Modular Commands: <500 lines per command
-├── Interactive Prompts: Smart context-aware UX
-├── Enhanced Hooks: Deep lifecycle integration
-├── Workflow Automation: Intelligent command orchestration
-└── Performance: <200ms command response time
-```
-
-### Modular Command Architecture
-
-```typescript
-// src/cli/core/command-registry.ts
-interface CommandModule {
-  name: string;
-  description: string;
-  category: CommandCategory;
-  handler: CommandHandler;
-  middleware: MiddlewareStack;
-  permissions: Permission[];
-  examples: CommandExample[];
-}
-
-export class ModularCommandRegistry {
-  private commands = new Map<string, CommandModule>();
-  private categories = new Map<CommandCategory, CommandModule[]>();
-  private aliases = new Map<string, string>();
-
-  registerCommand(command: CommandModule): void {
-    this.commands.set(command.name, command);
-
-    // Register in category index
-    if (!this.categories.has(command.category)) {
-      this.categories.set(command.category, []);
-    }
-    this.categories.get(command.category)!.push(command);
-  }
-
-  async executeCommand(name: string, args: string[]): Promise<CommandResult> {
-    const command = this.resolveCommand(name);
-    if (!command) {
-      throw new CommandNotFoundError(name, this.getSuggestions(name));
-    }
-
-    // Execute middleware stack
-    const context = await this.buildExecutionContext(command, args);
-    const result = await command.middleware.execute(context);
-
-    return result;
-  }
-
-  private resolveCommand(name: string): CommandModule | undefined {
-    // Try exact match first
-    if (this.commands.has(name)) {
-      return this.commands.get(name);
-    }
-
-    // Try alias
-    const aliasTarget = this.aliases.get(name);
-    if (aliasTarget) {
-      return this.commands.get(aliasTarget);
-    }
-
-    // Try fuzzy match
-    return this.findFuzzyMatch(name);
-  }
-}
-```
-
-## Command Decomposition Strategy
-
-### Swarm Commands Module
-
-```typescript
-// src/cli/commands/swarm/swarm.command.ts
-@Command({
-  name: "swarm",
-  description: "Swarm coordination and management",
-  category: "orchestration",
-})
-export class SwarmCommand {
-  constructor(
-    private swarmCoordinator: UnifiedSwarmCoordinator,
-    private promptService: InteractivePromptService,
-  ) {}
-
-  @SubCommand("init")
-  @Option(
-    "--topology",
-    "Swarm topology (mesh|hierarchical|adaptive)",
-    "hierarchical",
-  )
-  @Option("--agents", "Number of agents to spawn", 5)
-  @Option("--interactive", "Interactive agent configuration", false)
-  async init(
-    @Arg("projectName") projectName: string,
-    options: SwarmInitOptions,
-  ): Promise<CommandResult> {
-    if (options.interactive) {
-      return this.interactiveSwarmInit(projectName);
-    }
-
-    return this.quickSwarmInit(projectName, options);
-  }
-
-  private async interactiveSwarmInit(
-    projectName: string,
-  ): Promise<CommandResult> {
-    console.log(`🚀 Initializing Swarm for ${projectName}`);
-
-    // Interactive topology selection
-    const topology = await this.promptService.select({
-      message: "Select swarm topology:",
-      choices: [
-        {
-          name: "Hierarchical (Queen-led coordination)",
-          value: "hierarchical",
-        },
-        { name: "Mesh (Peer-to-peer collaboration)", value: "mesh" },
-        { name: "Adaptive (Dynamic topology switching)", value: "adaptive" },
-      ],
-    });
-
-    // Agent configuration
-    const agents = await this.promptAgentConfiguration();
-
-    // Initialize with configuration
-    const swarm = await this.swarmCoordinator.initialize({
-      name: projectName,
-      topology,
-      agents,
-      hooks: {
-        onAgentSpawn: this.handleAgentSpawn.bind(this),
-        onTaskComplete: this.handleTaskComplete.bind(this),
-        onSwarmComplete: this.handleSwarmComplete.bind(this),
-      },
-    });
-
-    return CommandResult.success({
-      message: `✅ Swarm ${projectName} initialized with ${agents.length} agents`,
-      data: { swarmId: swarm.id, topology, agentCount: agents.length },
-    });
-  }
-
-  @SubCommand("status")
-  async status(): Promise<CommandResult> {
-    const swarms = await this.swarmCoordinator.listActiveSwarms();
-
-    if (swarms.length === 0) {
-      return CommandResult.info("No active swarms found");
-    }
-
-    // Interactive swarm selection if multiple
-    const selectedSwarm =
-      swarms.length === 1
-        ? swarms[0]
-        : await this.promptService.select({
-            message: "Select swarm to inspect:",
-            choices: swarms.map((s) => ({
-              name: `${s.name} (${s.agents.length} agents, ${s.topology})`,
-              value: s,
-            })),
-          });
-
-    return this.displaySwarmStatus(selectedSwarm);
-  }
-}
-```
-
-### Learning Commands Module
-
-```typescript
-// src/cli/commands/learning/learning.command.ts
-@Command({
-  name: "learning",
-  description: "Learning system management and optimization",
-  category: "intelligence",
-})
-export class LearningCommand {
-  constructor(
-    private learningService: IntegratedLearningService,
-    private promptService: InteractivePromptService,
-  ) {}
-
-  @SubCommand("start")
-  @Option("--algorithm", "RL algorithm to use", "auto")
-  @Option("--tier", "Learning tier (basic|standard|advanced)", "standard")
-  async start(options: LearningStartOptions): Promise<CommandResult> {
-    // Auto-detect optimal algorithm if not specified
-    if (options.algorithm === "auto") {
-      const taskContext = await this.analyzeCurrentContext();
-      options.algorithm =
-        this.learningService.selectOptimalAlgorithm(taskContext);
-
-      console.log(
-        `🧠 Auto-selected ${options.algorithm} algorithm based on context`,
-      );
-    }
-
-    const session = await this.learningService.startSession({
-      algorithm: options.algorithm,
-      tier: options.tier,
-      userId: await this.getCurrentUser(),
-    });
-
-    return CommandResult.success({
-      message: `🚀 Learning session started with ${options.algorithm}`,
-      data: {
-        sessionId: session.id,
-        algorithm: options.algorithm,
-        tier: options.tier,
-      },
-    });
-  }
-
-  @SubCommand("feedback")
-  @Arg("reward", "Reward value (0-1)", "number")
-  async feedback(
-    @Arg("reward") reward: number,
-    @Option("--context", "Additional context for learning")
-    context?: string,
-  ): Promise<CommandResult> {
-    const activeSession = await this.learningService.getActiveSession();
-    if (!activeSession) {
-      return CommandResult.error(
-        "No active learning session found. Start one with `learning start`",
-      );
-    }
-
-    await this.learningService.submitFeedback({
-      sessionId: activeSession.id,
-      reward,
-      context,
-      timestamp: new Date(),
-    });
-
-    return CommandResult.success({
-      message: `📊 Feedback recorded (reward: ${reward})`,
-      data: { reward, sessionId: activeSession.id },
-    });
-  }
-
-  @SubCommand("metrics")
-  async metrics(): Promise<CommandResult> {
-    const metrics = await this.learningService.getMetrics();
-
-    // Interactive metrics display
-    await this.displayInteractiveMetrics(metrics);
-
-    return CommandResult.success("Metrics displayed");
-  }
-}
-```
-
-## Interactive Prompt System
-
-### Advanced Prompt Service
-
-```typescript
-// src/cli/services/interactive-prompt.service.ts
-interface PromptOptions {
-  message: string;
-  type: "select" | "multiselect" | "input" | "confirm" | "progress";
-  choices?: PromptChoice[];
-  default?: any;
-  validate?: (input: any) => boolean | string;
-  transform?: (input: any) => any;
-}
-
-export class InteractivePromptService {
-  private inquirer: any; // Dynamic import for tree-shaking
-
-  async select<T>(options: SelectPromptOptions<T>): Promise<T> {
-    const { default: inquirer } = await import("inquirer");
-
-    const result = await inquirer.prompt([
-      {
-        type: "list",
-        name: "selection",
-        message: options.message,
-        choices: options.choices,
-        default: options.default,
-      },
-    ]);
-
-    return result.selection;
-  }
-
-  async multiSelect<T>(options: MultiSelectPromptOptions<T>): Promise<T[]> {
-    const { default: inquirer } = await import("inquirer");
-
-    const result = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "selections",
-        message: options.message,
-        choices: options.choices,
-        validate: (input: T[]) => {
-          if (options.minSelections && input.length < options.minSelections) {
-            return `Please select at least ${options.minSelections} options`;
-          }
-          if (options.maxSelections && input.length > options.maxSelections) {
-            return `Please select at most ${options.maxSelections} options`;
-          }
-          return true;
-        },
-      },
-    ]);
-
-    return result.selections;
-  }
-
-  async input(options: InputPromptOptions): Promise<string> {
-    const { default: inquirer } = await import("inquirer");
-
-    const result = await inquirer.prompt([
-      {
-        type: "input",
-        name: "input",
-        message: options.message,
-        default: options.default,
-        validate: options.validate,
-        transformer: options.transform,
-      },
-    ]);
-
-    return result.input;
-  }
-
-  async progressTask<T>(
-    task: ProgressTask<T>,
-    options: ProgressOptions,
-  ): Promise<T> {
-    const { default: cliProgress } = await import("cli-progress");
-
-    const progressBar = new cliProgress.SingleBar({
-      format: `${options.title} |{bar}| {percentage}% | {status}`,
-      barCompleteChar: "█",
-      barIncompleteChar: "░",
-      hideCursor: true,
-    });
-
-    progressBar.start(100, 0, { status: "Starting..." });
-
-    try {
-      const result = await task({
-        updateProgress: (percent: number, status?: string) => {
-          progressBar.update(percent, { status: status || "Processing..." });
-        },
-      });
-
-      progressBar.update(100, { status: "Complete!" });
-      progressBar.stop();
-
-      return result;
-    } catch (error) {
-      progressBar.stop();
-      throw error;
-    }
-  }
-
-  async confirmWithDetails(
-    message: string,
-    details: ConfirmationDetails,
-  ): Promise<boolean> {
-    console.log("\n" + chalk.bold(message));
-    console.log(chalk.gray("Details:"));
-
-    for (const [key, value] of Object.entries(details)) {
-      console.log(chalk.gray(`  ${key}: ${value}`));
-    }
-
-    return this.confirm("\nProceed?");
-  }
-}
-```
-
-## Enhanced Hooks Integration
-
-### Deep CLI Hooks Integration
-
-```typescript
-// src/cli/hooks/cli-hooks-manager.ts
-interface CLIHookEvent {
-  type:
-    | "command_start"
-    | "command_end"
-    | "command_error"
-    | "agent_spawn"
-    | "task_complete";
-  command: string;
-  args: string[];
-  context: ExecutionContext;
-  timestamp: Date;
-}
-
-export class CLIHooksManager {
-  private hooks: Map<string, HookHandler[]> = new Map();
-  private learningIntegration: LearningHooksIntegration;
-
-  constructor() {
-    this.learningIntegration = new LearningHooksIntegration();
-    this.setupDefaultHooks();
-  }
-
-  private setupDefaultHooks(): void {
-    // Learning integration hooks
-    this.registerHook("command_start", async (event: CLIHookEvent) => {
-      await this.learningIntegration.recordCommandStart(event);
-    });
-
-    this.registerHook("command_end", async (event: CLIHookEvent) => {
-      await this.learningIntegration.recordCommandSuccess(event);
-    });
-
-    this.registerHook("command_error", async (event: CLIHookEvent) => {
-      await this.learningIntegration.recordCommandError(event);
-    });
-
-    // Intelligent suggestions
-    this.registerHook("command_start", async (event: CLIHookEvent) => {
-      const suggestions = await this.generateIntelligentSuggestions(event);
-      if (suggestions.length > 0) {
-        this.displaySuggestions(suggestions);
-      }
-    });
-
-    // Performance monitoring
-    this.registerHook("command_end", async (event: CLIHookEvent) => {
-      await this.recordPerformanceMetrics(event);
-    });
-  }
-
-  async executeHooks(type: string, event: CLIHookEvent): Promise<void> {
-    const handlers = this.hooks.get(type) || [];
-
-    await Promise.all(
-      handlers.map((handler) => this.executeHookSafely(handler, event)),
-    );
-  }
-
-  private async generateIntelligentSuggestions(
-    event: CLIHookEvent,
-  ): Promise<Suggestion[]> {
-    const context = await this.learningIntegration.getExecutionContext(event);
-    const patterns =
-      await this.learningIntegration.findSimilarPatterns(context);
-
-    return patterns.map((pattern) => ({
-      type: "optimization",
-      message: `Based on similar executions, consider: ${pattern.suggestion}`,
-      confidence: pattern.confidence,
-    }));
-  }
-}
-```
-
-### Learning Integration
-
-```typescript
-// src/cli/hooks/learning-hooks-integration.ts
-export class LearningHooksIntegration {
-  constructor(
-    private agenticFlowHooks: AgenticFlowHooksClient,
-    private agentDBLearning: AgentDBLearningClient,
-  ) {}
-
-  async recordCommandStart(event: CLIHookEvent): Promise<void> {
-    // Start trajectory tracking
-    await this.agenticFlowHooks.trajectoryStart({
-      sessionId: event.context.sessionId,
-      command: event.command,
-      args: event.args,
-      context: event.context,
-    });
-
-    // Record experience in AgentDB
-    await this.agentDBLearning.recordExperience({
-      type: "command_execution",
-      state: this.encodeCommandState(event),
-      action: event.command,
-      timestamp: event.timestamp,
-    });
-  }
-
-  async recordCommandSuccess(event: CLIHookEvent): Promise<void> {
-    const executionTime = Date.now() - event.timestamp.getTime();
-    const reward = this.calculateReward(event, executionTime, true);
-
-    // Complete trajectory
-    await this.agenticFlowHooks.trajectoryEnd({
-      sessionId: event.context.sessionId,
-      success: true,
-      reward,
-      verdict: "positive",
-    });
-
-    // Submit feedback to learning system
-    await this.agentDBLearning.submitFeedback({
-      sessionId: event.context.learningSessionId,
-      reward,
-      success: true,
-      latencyMs: executionTime,
-    });
-
-    // Store successful pattern
-    if (reward > 0.8) {
-      await this.agenticFlowHooks.storePattern({
-        pattern: event.command,
-        solution: event.context.result,
-        confidence: reward,
-      });
-    }
-  }
-
-  async recordCommandError(event: CLIHookEvent): Promise<void> {
-    const executionTime = Date.now() - event.timestamp.getTime();
-    const reward = this.calculateReward(event, executionTime, false);
-
-    // Complete trajectory with error
-    await this.agenticFlowHooks.trajectoryEnd({
-      sessionId: event.context.sessionId,
-      success: false,
-      reward,
-      verdict: "negative",
-      error: event.context.error,
-    });
-
-    // Learn from failure
-    await this.agentDBLearning.submitFeedback({
-      sessionId: event.context.learningSessionId,
-      reward,
-      success: false,
-      latencyMs: executionTime,
-      error: event.context.error,
-    });
-  }
-
-  private calculateReward(
-    event: CLIHookEvent,
-    executionTime: number,
-    success: boolean,
-  ): number {
-    if (!success) return 0;
-
-    // Base reward for success
-    let reward = 0.5;
-
-    // Performance bonus (faster execution)
-    const expectedTime = this.getExpectedExecutionTime(event.command);
-    if (executionTime < expectedTime) {
-      reward += 0.3 * (1 - executionTime / expectedTime);
-    }
-
-    // Complexity bonus
-    const complexity = this.calculateCommandComplexity(event);
-    reward += complexity * 0.2;
-
-    return Math.min(reward, 1.0);
-  }
-}
-```
-
-## Intelligent Workflow Automation
-
-### Workflow Orchestrator
-
-```typescript
-// src/cli/workflows/workflow-orchestrator.ts
-interface WorkflowStep {
-  id: string;
-  command: string;
-  args: string[];
-  dependsOn: string[];
-  condition?: WorkflowCondition;
-  retryPolicy?: RetryPolicy;
-}
-
-export class WorkflowOrchestrator {
-  constructor(
-    private commandRegistry: ModularCommandRegistry,
-    private promptService: InteractivePromptService,
-  ) {}
-
-  async executeWorkflow(workflow: Workflow): Promise<WorkflowResult> {
-    const context = new WorkflowExecutionContext(workflow);
-
-    // Display workflow overview
-    await this.displayWorkflowOverview(workflow);
-
-    const confirmed = await this.promptService.confirm(
-      "Execute this workflow?",
-    );
-
-    if (!confirmed) {
-      return WorkflowResult.cancelled();
-    }
-
-    // Execute steps
-    return this.promptService.progressTask(
-      async ({ updateProgress }) => {
-        const steps = this.sortStepsByDependencies(workflow.steps);
-
-        for (let i = 0; i < steps.length; i++) {
-          const step = steps[i];
-          updateProgress((i / steps.length) * 100, `Executing ${step.command}`);
-
-          await this.executeStep(step, context);
-        }
-
-        return WorkflowResult.success(context.getResults());
-      },
-      { title: `Workflow: ${workflow.name}` },
-    );
-  }
-
-  async generateWorkflowFromIntent(intent: string): Promise<Workflow> {
-    // Use learning system to generate workflow
-    const patterns = await this.findWorkflowPatterns(intent);
-
-    if (patterns.length === 0) {
-      throw new Error("Could not generate workflow for intent");
-    }
-
-    // Select best pattern or let user choose
-    const selectedPattern =
-      patterns.length === 1
-        ? patterns[0]
-        : await this.promptService.select({
-            message: "Select workflow template:",
-            choices: patterns.map((p) => ({
-              name: `${p.name} (${p.confidence}% match)`,
-              value: p,
-            })),
-          });
-
-    return this.customizeWorkflow(selectedPattern, intent);
-  }
-
-  private async executeStep(
-    step: WorkflowStep,
-    context: WorkflowExecutionContext,
-  ): Promise<void> {
-    // Check conditions
-    if (step.condition && !this.evaluateCondition(step.condition, context)) {
-      context.skipStep(step.id, "Condition not met");
-      return;
-    }
-
-    // Check dependencies
-    const missingDeps = step.dependsOn.filter(
-      (dep) => !context.isStepCompleted(dep),
-    );
-    if (missingDeps.length > 0) {
-      throw new WorkflowError(
-        `Step ${step.id} has unmet dependencies: ${missingDeps.join(", ")}`,
-      );
-    }
-
-    // Execute with retry policy
-    const retryPolicy = step.retryPolicy || { maxAttempts: 1 };
-    let lastError: Error | null = null;
-
-    for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt++) {
-      try {
-        const result = await this.commandRegistry.executeCommand(
-          step.command,
-          step.args,
-        );
-        context.completeStep(step.id, result);
-        return;
-      } catch (error) {
-        lastError = error as Error;
-
-        if (attempt < retryPolicy.maxAttempts) {
-          await this.delay(retryPolicy.backoffMs || 1000);
-        }
-      }
-    }
-
-    throw new WorkflowError(
-      `Step ${step.id} failed after ${retryPolicy.maxAttempts} attempts: ${lastError?.message}`,
-    );
-  }
-}
-```
-
-## Performance Optimization
-
-### Command Performance Monitoring
-
-```typescript
-// src/cli/performance/command-performance.ts
-export class CommandPerformanceMonitor {
-  private metrics = new Map<string, CommandMetrics>();
-
-  async measureCommand<T>(
-    commandName: string,
-    executor: () => Promise<T>,
-  ): Promise<T> {
-    const start = performance.now();
-    const memBefore = process.memoryUsage();
-
-    try {
-      const result = await executor();
-      const end = performance.now();
-      const memAfter = process.memoryUsage();
-
-      this.recordMetrics(commandName, {
-        executionTime: end - start,
-        memoryDelta: memAfter.heapUsed - memBefore.heapUsed,
-        success: true,
-      });
-
-      return result;
-    } catch (error) {
-      const end = performance.now();
-
-      this.recordMetrics(commandName, {
-        executionTime: end - start,
-        memoryDelta: 0,
-        success: false,
-        error: error as Error,
-      });
-
-      throw error;
-    }
-  }
-
-  private recordMetrics(
-    command: string,
-    measurement: PerformanceMeasurement,
-  ): void {
-    if (!this.metrics.has(command)) {
-      this.metrics.set(command, new CommandMetrics(command));
-    }
-
-    const metrics = this.metrics.get(command)!;
-    metrics.addMeasurement(measurement);
-
-    // Alert if performance degrades
-    if (metrics.getP95ExecutionTime() > 5000) {
-      // 5 seconds
-      console.warn(
-        `⚠️  Command '${command}' is performing slowly (P95: ${metrics.getP95ExecutionTime()}ms)`,
-      );
-    }
-  }
-
-  getCommandReport(command: string): PerformanceReport {
-    const metrics = this.metrics.get(command);
-    if (!metrics) {
-      throw new Error(`No metrics found for command: ${command}`);
-    }
-
-    return {
-      command,
-      totalExecutions: metrics.getTotalExecutions(),
-      successRate: metrics.getSuccessRate(),
-      avgExecutionTime: metrics.getAverageExecutionTime(),
-      p95ExecutionTime: metrics.getP95ExecutionTime(),
-      avgMemoryUsage: metrics.getAverageMemoryUsage(),
-      recommendations: this.generateRecommendations(metrics),
-    };
-  }
-}
-```
-
-## Smart Auto-completion
-
-### Intelligent Command Completion
-
-```typescript
-// src/cli/completion/intelligent-completion.ts
-export class IntelligentCompletion {
-  constructor(
-    private learningService: LearningService,
-    private commandRegistry: ModularCommandRegistry,
-  ) {}
-
-  async generateCompletions(
-    partial: string,
-    context: CompletionContext,
-  ): Promise<Completion[]> {
-    const completions: Completion[] = [];
-
-    // 1. Exact command matches
-    const exactMatches = this.commandRegistry.findCommandsByPrefix(partial);
-    completions.push(
-      ...exactMatches.map((cmd) => ({
-        value: cmd.name,
-        description: cmd.description,
-        type: "command",
-        confidence: 1.0,
-      })),
-    );
-
-    // 2. Learning-based suggestions
-    const learnedSuggestions = await this.learningService.suggestCommands(
-      partial,
-      context,
-    );
-    completions.push(...learnedSuggestions);
-
-    // 3. Context-aware suggestions
-    const contextualSuggestions = await this.generateContextualSuggestions(
-      partial,
-      context,
-    );
-    completions.push(...contextualSuggestions);
-
-    // Sort by confidence and relevance
-    return completions.sort((a, b) => b.confidence - a.confidence).slice(0, 10); // Top 10 suggestions
-  }
-
-  private async generateContextualSuggestions(
-    partial: string,
-    context: CompletionContext,
-  ): Promise<Completion[]> {
-    const suggestions: Completion[] = [];
-
-    // If in git repository, suggest git-related commands
-    if (context.isGitRepository) {
-      if (partial.startsWith("git")) {
-        suggestions.push({
-          value: "git commit",
-          description: "Create git commit with generated message",
-          type: "workflow",
-          confidence: 0.8,
-        });
-      }
-    }
-
-    // If package.json exists, suggest npm commands
-    if (context.hasPackageJson) {
-      if (partial.startsWith("npm") || partial.startsWith("swarm")) {
-        suggestions.push({
-          value: "swarm init",
-          description: "Initialize swarm for this project",
-          type: "workflow",
-          confidence: 0.9,
-        });
-      }
-    }
-
-    return suggestions;
-  }
-}
-```
-
-## Success Metrics
-
-### CLI Performance Targets
-
-- [ ] **Command Response**: <200ms average command execution time
-- [ ] **File Decomposition**: index.ts (108KB) → <10KB per command module
-- [ ] **Interactive UX**: Smart prompts with context awareness
-- [ ] **Hook Integration**: Deep lifecycle integration with learning
-- [ ] **Workflow Automation**: Intelligent multi-step command orchestration
-- [ ] **Auto-completion**: >90% accuracy for command suggestions
-
-### User Experience Improvements
-
-```typescript
-const cliImprovements = {
-  before: {
-    commandResponse: "~500ms",
-    interactivity: "Basic command parsing",
-    workflows: "Manual command chaining",
-    suggestions: "Static help text",
-  },
-
-  after: {
-    commandResponse: "<200ms with caching",
-    interactivity: "Smart context-aware prompts",
-    workflows: "Automated multi-step execution",
-    suggestions: "Learning-based intelligent completion",
-  },
-};
-```
-
-## Related Skills
-
-- `core-implementation` - Core domain integration
-- `memory-unification` - Memory-backed command caching
-- `swarm-coordination` - CLI swarm management integration
-- `performance-optimization` - CLI performance monitoring
-
-## Usage Examples
-
-### Complete CLI Modernization
-
-```bash
-# Full CLI modernization implementation
-Task("CLI modernization implementation",
-     "Implement modular commands, interactive prompts, and intelligent workflows",
-     "cli-hooks-developer")
-```
-
-### Interactive Command Enhancement
-
-```bash
-# Enhanced interactive commands
-monomind swarm init --interactive
-monomind learning start --guided
-monomind workflow create --from-intent "setup new project"
-```