claude-flow 1.0.0

package/src/cli/formatter.ts

@@ -0,0 +1,310 @@
+/**
+ * Output formatting utilities for CLI
+ */
+
+import { colors } from '@cliffy/ansi/colors';
+import { Table } from '@cliffy/table';
+// Box is not available in the current cliffy version
+import { AgentProfile, Task, MemoryEntry, HealthStatus } from '../utils/types.ts';
+
+/**
+ * Formats an error for display
+ */
+export function formatError(error: unknown): string {
+  if (error instanceof Error) {
+    let message = error.message;
+    
+    if ('code' in error) {
+      message = `[${(error as any).code}] ${message}`;
+    }
+    
+    if ('details' in error && (error as any).details) {
+      message += '\n' + colors.gray('Details: ' + JSON.stringify((error as any).details, null, 2));
+    }
+    
+    return message;
+  }
+  
+  return String(error);
+}
+
+/**
+ * Formats an agent profile for display
+ */
+export function formatAgent(agent: AgentProfile): string {
+  const lines = [
+    colors.cyan.bold(`Agent: ${agent.name}`),
+    colors.gray(`ID: ${agent.id}`),
+    colors.gray(`Type: ${agent.type}`),
+    colors.gray(`Priority: ${agent.priority}`),
+    colors.gray(`Max Tasks: ${agent.maxConcurrentTasks}`),
+    colors.gray(`Capabilities: ${agent.capabilities.join(', ')}`),
+  ];
+  
+  return lines.join('\n');
+}
+
+/**
+ * Formats a task for display
+ */
+export function formatTask(task: Task): string {
+  const statusColor = {
+    pending: colors.gray,
+    queued: colors.yellow,
+    assigned: colors.blue,
+    running: colors.cyan,
+    completed: colors.green,
+    failed: colors.red,
+    cancelled: colors.magenta,
+  }[task.status] || colors.white;
+
+  const lines = [
+    colors.yellow.bold(`Task: ${task.description}`),
+    colors.gray(`ID: ${task.id}`),
+    colors.gray(`Type: ${task.type}`),
+    statusColor(`Status: ${task.status}`),
+    colors.gray(`Priority: ${task.priority}`),
+  ];
+
+  if (task.assignedAgent) {
+    lines.push(colors.gray(`Assigned to: ${task.assignedAgent}`));
+  }
+
+  if (task.dependencies.length > 0) {
+    lines.push(colors.gray(`Dependencies: ${task.dependencies.join(', ')}`));
+  }
+
+  if (task.error) {
+    lines.push(colors.red(`Error: ${task.error.message}`));
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Formats a memory entry for display
+ */
+export function formatMemoryEntry(entry: MemoryEntry): string {
+  const lines = [
+    colors.magenta.bold(`Memory Entry: ${entry.type}`),
+    colors.gray(`ID: ${entry.id}`),
+    colors.gray(`Agent: ${entry.agentId}`),
+    colors.gray(`Session: ${entry.sessionId}`),
+    colors.gray(`Timestamp: ${entry.timestamp.toISOString()}`),
+    colors.gray(`Version: ${entry.version}`),
+  ];
+
+  if (entry.tags.length > 0) {
+    lines.push(colors.gray(`Tags: ${entry.tags.join(', ')}`));
+  }
+
+  lines.push('', colors.white('Content:'), entry.content);
+
+  return lines.join('\n');
+}
+
+/**
+ * Formats health status for display
+ */
+export function formatHealthStatus(health: HealthStatus): string {
+  const statusColor = {
+    healthy: colors.green,
+    degraded: colors.yellow,
+    unhealthy: colors.red,
+  }[health.status];
+
+  const lines = [
+    statusColor.bold(`System Status: ${health.status.toUpperCase()}`),
+    colors.gray(`Checked at: ${health.timestamp.toISOString()}`),
+    '',
+    colors.cyan.bold('Components:'),
+  ];
+
+  for (const [name, component] of Object.entries(health.components)) {
+    const compColor = {
+      healthy: colors.green,
+      degraded: colors.yellow,
+      unhealthy: colors.red,
+    }[component.status];
+
+    lines.push(compColor(`  ${name}: ${component.status}`));
+    
+    if (component.error) {
+      lines.push(colors.red(`    Error: ${component.error}`));
+    }
+
+    if (component.metrics) {
+      for (const [metric, value] of Object.entries(component.metrics)) {
+        lines.push(colors.gray(`    ${metric}: ${value}`));
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Creates a table for agent listing
+ */
+export function createAgentTable(agents: AgentProfile[]): Table {
+  const table = new Table()
+    .header(['ID', 'Name', 'Type', 'Priority', 'Max Tasks'])
+    .border(true);
+
+  for (const agent of agents) {
+    table.push([
+      agent.id,
+      agent.name,
+      agent.type,
+      agent.priority.toString(),
+      agent.maxConcurrentTasks.toString(),
+    ]);
+  }
+
+  return table;
+}
+
+/**
+ * Creates a table for task listing
+ */
+export function createTaskTable(tasks: Task[]): Table {
+  const table = new Table()
+    .header(['ID', 'Type', 'Description', 'Status', 'Agent'])
+    .border(true);
+
+  for (const task of tasks) {
+    const statusCell = {
+      pending: colors.gray(task.status),
+      queued: colors.yellow(task.status),
+      assigned: colors.blue(task.status),
+      running: colors.cyan(task.status),
+      completed: colors.green(task.status),
+      failed: colors.red(task.status),
+      cancelled: colors.magenta(task.status),
+    }[task.status] || task.status;
+
+    table.push([
+      task.id,
+      task.type,
+      task.description.substring(0, 40) + (task.description.length > 40 ? '...' : ''),
+      statusCell,
+      task.assignedAgent || '-',
+    ]);
+  }
+
+  return table;
+}
+
+/**
+ * Formats duration in human-readable form
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) {
+    return `${days}d ${hours % 24}h`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  
+  return `${seconds}s`;
+}
+
+/**
+ * Displays the Claude-Flow banner
+ */
+export function displayBanner(version: string): void {
+  const banner = `
+${colors.cyan.bold('╔══════════════════════════════════════════════════════════════╗')}
+${colors.cyan.bold('║')}             ${colors.white.bold('🧠 Claude-Flow')} ${colors.gray('v' + version)}                        ${colors.cyan.bold('║')}
+${colors.cyan.bold('║')}          ${colors.gray('Advanced AI Agent Orchestration')}               ${colors.cyan.bold('║')}
+${colors.cyan.bold('╚══════════════════════════════════════════════════════════════╝')}
+`;
+  console.log(banner);
+}
+
+/**
+ * Displays detailed version information
+ */
+export function displayVersion(version: string, buildDate: string): void {
+  const info = [
+    colors.cyan.bold('Claude-Flow Version Information'),
+    '',
+    colors.white('Version:    ') + colors.yellow(version),
+    colors.white('Build Date: ') + colors.yellow(buildDate),
+    colors.white('Runtime:    ') + colors.yellow('Deno ' + Deno.version.deno),
+    colors.white('TypeScript: ') + colors.yellow(Deno.version.typescript),
+    colors.white('V8:         ') + colors.yellow(Deno.version.v8),
+    '',
+    colors.gray('Components:'),
+    colors.white('  • Multi-Agent Orchestration'),
+    colors.white('  • Memory Management'),
+    colors.white('  • Terminal Integration'),
+    colors.white('  • MCP Server'),
+    colors.white('  • Task Coordination'),
+    '',
+    colors.blue('Homepage: ') + colors.underline('https://github.com/anthropics/claude-code-flow'),
+  ];
+  
+  console.log(info.join('\n'));
+}
+
+/**
+ * Formats a progress bar
+ */
+export function formatProgressBar(
+  current: number,
+  total: number,
+  width: number = 40,
+  label?: string
+): string {
+  const percentage = Math.min(100, (current / total) * 100);
+  const filled = Math.floor((percentage / 100) * width);
+  const empty = width - filled;
+  
+  const bar = colors.green('█'.repeat(filled)) + colors.gray('░'.repeat(empty));
+  const percent = percentage.toFixed(1).padStart(5) + '%';
+  
+  let result = `[${bar}] ${percent}`;
+  if (label) {
+    result = `${label}: ${result}`;
+  }
+  
+  return result;
+}
+
+/**
+ * Creates a status indicator
+ */
+export function formatStatusIndicator(status: string): string {
+  const indicators = {
+    success: colors.green('✓'),
+    error: colors.red('✗'),
+    warning: colors.yellow('⚠'),
+    info: colors.blue('ℹ'),
+    running: colors.cyan('⟳'),
+    pending: colors.gray('○'),
+  };
+  
+  return indicators[status as keyof typeof indicators] || status;
+}
+
+/**
+ * Formats a spinner with message
+ */
+export function formatSpinner(message: string, frame: number = 0): string {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  const spinner = colors.cyan(frames[frame % frames.length]);
+  return `${spinner} ${message}`;
+}

package/src/cli/index.ts

@@ -0,0 +1,211 @@
+#!/usr/bin/env -S deno run --allow-all
+/**
+ * Claude-Flow CLI entry point
+ * Advanced AI agent orchestration system
+ */
+
+import { Command } from '@cliffy/command';
+import { colors } from '@cliffy/ansi/colors';
+// Spinner import removed - not available in current cliffy version
+import { logger } from '../core/logger.ts';
+import { configManager } from '../core/config.ts';
+import { startCommand } from './commands/start.ts';
+import { agentCommand } from './commands/agent.ts';
+import { taskCommand } from './commands/task.ts';
+import { memoryCommand } from './commands/memory.ts';
+import { configCommand } from './commands/config.ts';
+import { statusCommand } from './commands/status.ts';
+import { monitorCommand } from './commands/monitor.ts';
+import { sessionCommand } from './commands/session.ts';
+import { workflowCommand } from './commands/workflow.ts';
+import { helpCommand } from './commands/help.ts';
+import { mcpCommand } from './commands/mcp.ts';
+import { formatError, displayBanner, displayVersion } from './formatter.ts';
+import { startREPL } from './repl.ts';
+import { CompletionGenerator } from './completion.ts';
+
+// Version information
+const VERSION = '1.0.0';
+const BUILD_DATE = new Date().toISOString().split('T')[0];
+
+// Main CLI command
+const cli = new Command()
+  .name('claude-flow')
+  .version(VERSION)
+  .description('Claude-Flow: Advanced AI agent orchestration system for multi-agent coordination')
+  .meta('Build', BUILD_DATE)
+  .meta('Runtime', 'Deno')
+  .globalOption('-c, --config <path:string>', 'Path to configuration file', {
+    default: './claude-flow.config.json',
+  })
+  .globalOption('-v, --verbose', 'Enable verbose logging')
+  .globalOption('-q, --quiet', 'Suppress non-essential output')
+  .globalOption('--log-level <level:string>', 'Set log level (debug, info, warn, error)', {
+    default: 'info',
+  })
+  .globalOption('--no-color', 'Disable colored output')
+  .globalOption('--json', 'Output in JSON format where applicable')
+  .globalOption('--profile <profile:string>', 'Use named configuration profile')
+  .action(async (options) => {
+    // If no subcommand, show banner and start REPL
+    await setupLogging(options);
+    
+    if (!options.quiet) {
+      displayBanner(VERSION);
+      console.log(colors.gray('Type "help" for available commands or "exit" to quit.\n'));
+    }
+    
+    await startREPL(options);
+  });
+
+// Add subcommands
+cli
+  .command('start', startCommand)
+  .command('agent', agentCommand)
+  .command('task', taskCommand)
+  .command('memory', memoryCommand)
+  .command('config', configCommand)
+  .command('status', statusCommand)
+  .command('monitor', monitorCommand)
+  .command('session', sessionCommand)
+  .command('workflow', workflowCommand)
+  .command('mcp', mcpCommand)
+  .command('help', helpCommand)
+  .command('repl', new Command()
+    .description('Start interactive REPL mode with command completion')
+    .option('--no-banner', 'Skip welcome banner')
+    .option('--history-file <path:string>', 'Custom history file path')
+    .action(async (options) => {
+      await setupLogging(options);
+      if (options.banner !== false) {
+        displayBanner(VERSION);
+      }
+      await startREPL(options);
+    }),
+  )
+  .command('version', new Command()
+    .description('Show detailed version information')
+    .option('--short', 'Show version number only')
+    .action(async (options) => {
+      if (options.short) {
+        console.log(VERSION);
+      } else {
+        displayVersion(VERSION, BUILD_DATE);
+      }
+    }),
+  )
+  .command('completion', new Command()
+    .description('Generate shell completion scripts')
+    .arguments('[shell:string]')
+    .option('--install', 'Install completion script automatically')
+    .action(async (options, shell) => {
+      const generator = new CompletionGenerator();
+      await generator.generate(shell || 'detect', options.install === true);
+    }),
+  );
+
+// Global error handler
+async function handleError(error: unknown, options?: any): Promise<void> {
+  const formatted = formatError(error);
+  
+  if (options?.json) {
+    console.error(JSON.stringify({
+      error: true,
+      message: formatted,
+      timestamp: new Date().toISOString(),
+    }));
+  } else {
+    console.error(colors.red(colors.bold('✗ Error:')), formatted);
+  }
+  
+  // Show stack trace in debug mode or verbose
+  if (Deno.env.get('CLAUDE_FLOW_DEBUG') === 'true' || options?.verbose) {
+    console.error(colors.gray('\nStack trace:'));
+    console.error(error);
+  }
+  
+  // Suggest helpful actions
+  if (!options?.quiet) {
+    console.error(colors.gray('\nTry running with --verbose for more details'));
+    console.error(colors.gray('Or use "claude-flow help" to see available commands'));
+  }
+  
+  Deno.exit(1);
+}
+
+// Setup logging and configuration based on CLI options
+async function setupLogging(options: any): Promise<void> {
+  // Determine log level
+  let logLevel = options.logLevel;
+  if (options.verbose) logLevel = 'debug';
+  if (options.quiet) logLevel = 'warn';
+  
+  // Configure logger
+  await logger.configure({
+    level: logLevel as any,
+    format: options.json ? 'json' : 'text',
+    destination: 'console',
+  });
+  
+  // Load configuration
+  try {
+    if (options.config) {
+      await configManager.load(options.config);
+    } else {
+      // Try to load default config file if it exists
+      try {
+        await configManager.load('./claude-flow.config.json');
+      } catch {
+        // Use default config if no file found
+        configManager.loadDefault();
+      }
+    }
+    
+    // Apply profile if specified
+    if (options.profile) {
+      await configManager.applyProfile(options.profile);
+    }
+  } catch (error) {
+    logger.warn('Failed to load configuration:', (error as Error).message);
+    configManager.loadDefault();
+  }
+}
+
+// Signal handlers for graceful shutdown
+function setupSignalHandlers(): void {
+  const gracefulShutdown = () => {
+    console.log('\n' + colors.gray('Gracefully shutting down...'));
+    Deno.exit(0);
+  };
+  
+  Deno.addSignalListener('SIGINT', gracefulShutdown);
+  Deno.addSignalListener('SIGTERM', gracefulShutdown);
+}
+
+// Main entry point
+if (import.meta.main) {
+  let globalOptions: any = {};
+  
+  try {
+    // Setup signal handlers
+    setupSignalHandlers();
+    
+    // Pre-parse global options for error handling
+    const args = Deno.args;
+    globalOptions = {
+      verbose: args.includes('-v') || args.includes('--verbose'),
+      quiet: args.includes('-q') || args.includes('--quiet'),
+      json: args.includes('--json'),
+      noColor: args.includes('--no-color'),
+    };
+    
+    // Configure colors based on options
+    if (globalOptions.noColor) {
+      colors.setColorEnabled(false);
+    }
+    
+    await cli.parse(args);
+  } catch (error) {
+    await handleError(error, globalOptions);
+  }
+}

package/src/cli/main.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env -S deno run --allow-all
+/**
+ * Claude-Flow CLI - Main entry point
+ */
+
+import { CLI } from "./cli-core.ts";
+import { setupCommands } from "./commands/index.ts";
+
+const VERSION = "1.0.0";
+
+async function main() {
+  const cli = new CLI("claude-flow", "Advanced AI Agent Orchestration System");
+  
+  // Setup all commands
+  setupCommands(cli);
+  
+  // Run the CLI
+  await cli.run();
+}
+
+if (import.meta.main) {
+  await main();
+}