claude-flow 1.0.0

package/scripts/validate-examples.ts

@@ -0,0 +1,288 @@
+#!/usr/bin/env deno run --allow-read
+
+/**
+ * Example Configuration Validator
+ * Validates all example configuration files for correctness
+ */
+
+import { walk } from "https://deno.land/std@0.220.0/fs/mod.ts";
+
+interface ValidationResult {
+  file: string;
+  valid: boolean;
+  errors: string[];
+}
+
+interface ConfigSchema {
+  [key: string]: {
+    type: string;
+    required?: boolean;
+    properties?: ConfigSchema;
+  };
+}
+
+const CLAUDE_FLOW_CONFIG_SCHEMA: ConfigSchema = {
+  orchestrator: {
+    type: 'object',
+    required: true,
+    properties: {
+      maxConcurrentAgents: { type: 'number' },
+      taskQueueSize: { type: 'number' },
+      healthCheckInterval: { type: 'number' },
+      shutdownTimeout: { type: 'number' },
+    },
+  },
+  terminal: {
+    type: 'object',
+    properties: {
+      type: { type: 'string' },
+      poolSize: { type: 'number' },
+      recycleAfter: { type: 'number' },
+      healthCheckInterval: { type: 'number' },
+      commandTimeout: { type: 'number' },
+    },
+  },
+  memory: {
+    type: 'object',
+    properties: {
+      backend: { type: 'string' },
+      cacheSizeMB: { type: 'number' },
+      syncInterval: { type: 'number' },
+      conflictResolution: { type: 'string' },
+      retentionDays: { type: 'number' },
+    },
+  },
+  coordination: {
+    type: 'object',
+    properties: {
+      maxRetries: { type: 'number' },
+      retryDelay: { type: 'number' },
+      deadlockDetection: { type: 'boolean' },
+      resourceTimeout: { type: 'number' },
+      messageTimeout: { type: 'number' },
+    },
+  },
+  mcp: {
+    type: 'object',
+    properties: {
+      transport: { type: 'string' },
+      port: { type: 'number' },
+      tlsEnabled: { type: 'boolean' },
+    },
+  },
+  logging: {
+    type: 'object',
+    properties: {
+      level: { type: 'string' },
+      format: { type: 'string' },
+      destination: { type: 'string' },
+    },
+  },
+};
+
+const WORKFLOW_SCHEMA: ConfigSchema = {
+  name: { type: 'string', required: true },
+  description: { type: 'string' },
+  tasks: {
+    type: 'array',
+    required: true,
+    properties: {
+      id: { type: 'string', required: true },
+      type: { type: 'string', required: true },
+      description: { type: 'string', required: true },
+      dependencies: { type: 'array' },
+      assignTo: { type: 'string' },
+      priority: { type: 'string' },
+      timeout: { type: 'number' },
+    },
+  },
+};
+
+function validateType(value: any, expectedType: string): boolean {
+  switch (expectedType) {
+    case 'string':
+      return typeof value === 'string';
+    case 'number':
+      return typeof value === 'number';
+    case 'boolean':
+      return typeof value === 'boolean';
+    case 'array':
+      return Array.isArray(value);
+    case 'object':
+      return typeof value === 'object' && value !== null && !Array.isArray(value);
+    default:
+      return false;
+  }
+}
+
+function validateObject(obj: any, schema: ConfigSchema, path = ''): string[] {
+  const errors: string[] = [];
+  
+  // Check required fields
+  for (const [key, spec] of Object.entries(schema)) {
+    if (spec.required && !(key in obj)) {
+      errors.push(`${path}${key} is required but missing`);
+      continue;
+    }
+    
+    if (key in obj) {
+      const value = obj[key];
+      const currentPath = path ? `${path}${key}.` : `${key}.`;
+      
+      if (!validateType(value, spec.type)) {
+        errors.push(`${path}${key} should be of type ${spec.type}, got ${typeof value}`);
+        continue;
+      }
+      
+      // Validate nested objects
+      if (spec.type === 'object' && spec.properties) {
+        errors.push(...validateObject(value, spec.properties, currentPath));
+      }
+      
+      // Validate array items
+      if (spec.type === 'array' && spec.properties && Array.isArray(value)) {
+        value.forEach((item, index) => {
+          if (typeof item === 'object') {
+            errors.push(...validateObject(item, spec.properties!, `${currentPath}[${index}].`));
+          }
+        });
+      }
+    }
+  }
+  
+  return errors;
+}
+
+function validateClaudeFlowConfig(config: any): string[] {
+  return validateObject(config, CLAUDE_FLOW_CONFIG_SCHEMA);
+}
+
+function validateWorkflow(workflow: any): string[] {
+  const errors = validateObject(workflow, WORKFLOW_SCHEMA);
+  
+  // Additional workflow-specific validations
+  if (workflow.tasks && Array.isArray(workflow.tasks)) {
+    const taskIds = new Set<string>();
+    
+    for (const [index, task] of workflow.tasks.entries()) {
+      // Check for duplicate task IDs
+      if (taskIds.has(task.id)) {
+        errors.push(`Duplicate task ID "${task.id}" found at index ${index}`);
+      } else {
+        taskIds.add(task.id);
+      }
+      
+      // Validate dependencies reference existing tasks
+      if (task.dependencies && Array.isArray(task.dependencies)) {
+        for (const dep of task.dependencies) {
+          if (!taskIds.has(dep) && !workflow.tasks.slice(0, index).some((t: any) => t.id === dep)) {
+            errors.push(`Task "${task.id}" depends on non-existent task "${dep}"`);
+          }
+        }
+      }
+      
+      // Validate priority values
+      if (task.priority && !['low', 'medium', 'high', 'critical'].includes(task.priority)) {
+        errors.push(`Task "${task.id}" has invalid priority "${task.priority}"`);
+      }
+      
+      // Validate timeout is positive
+      if (task.timeout && task.timeout <= 0) {
+        errors.push(`Task "${task.id}" has invalid timeout ${task.timeout}`);
+      }
+    }
+  }
+  
+  return errors;
+}
+
+async function validateFile(filePath: string): Promise<ValidationResult> {
+  const result: ValidationResult = {
+    file: filePath,
+    valid: false,
+    errors: [],
+  };
+  
+  try {
+    const content = await Deno.readTextFile(filePath);
+    const config = JSON.parse(content);
+    
+    // Determine validation type based on file name/content
+    if (filePath.includes('workflow') || config.tasks) {
+      result.errors = validateWorkflow(config);
+    } else if (filePath.includes('config') || config.orchestrator) {
+      result.errors = validateClaudeFlowConfig(config);
+    } else {
+      result.errors.push('Unknown configuration file type');
+    }
+    
+    result.valid = result.errors.length === 0;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      result.errors.push(`Invalid JSON: ${error.message}`);
+    } else {
+      result.errors.push(`Failed to read file: ${error.message}`);
+    }
+  }
+  
+  return result;
+}
+
+async function main(): Promise<void> {
+  console.log('Validating example configurations...\n');
+  
+  const results: ValidationResult[] = [];
+  
+  // Find all JSON files in examples directory
+  for await (const entry of walk('./examples', { exts: ['.json'] })) {
+    if (entry.isFile) {
+      const result = await validateFile(entry.path);
+      results.push(result);
+    }
+  }
+  
+  // Also check any config files in the root
+  const rootConfigFiles = ['claude-flow.config.json', 'config.json'];
+  for (const filename of rootConfigFiles) {
+    try {
+      await Deno.stat(filename);
+      const result = await validateFile(filename);
+      results.push(result);
+    } catch {
+      // File doesn't exist, skip
+    }
+  }
+  
+  if (results.length === 0) {
+    console.log('No configuration files found to validate.');
+    return;
+  }
+  
+  // Report results
+  let hasErrors = false;
+  
+  for (const result of results) {
+    if (result.valid) {
+      console.log(`✅ ${result.file}: Valid`);
+    } else {
+      console.log(`❌ ${result.file}: Invalid`);
+      for (const error of result.errors) {
+        console.log(`   - ${error}`);
+      }
+      hasErrors = true;
+    }
+  }
+  
+  console.log(`\nValidated ${results.length} configuration files.`);
+  
+  if (hasErrors) {
+    console.error('❌ Some configuration files have errors!');
+    Deno.exit(1);
+  } else {
+    console.log('✅ All configuration files are valid!');
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}

package/src/cli/cli-core.ts

@@ -0,0 +1,273 @@
+#!/usr/bin/env -S deno run --allow-all
+/**
+ * Claude-Flow CLI - Core implementation without external dependencies
+ */
+
+import { parse } from "https://deno.land/std@0.224.0/flags/mod.ts";
+import { red, green, yellow, blue, bold, cyan } from "https://deno.land/std@0.224.0/fmt/colors.ts";
+import { ensureDir } from "https://deno.land/std@0.224.0/fs/mod.ts";
+import { join } from "https://deno.land/std@0.224.0/path/mod.ts";
+
+export const VERSION = "1.0.0";
+
+interface CommandContext {
+  args: string[];
+  flags: Record<string, unknown>;
+  config?: Record<string, unknown> | undefined;
+}
+
+interface Command {
+  name: string;
+  description: string;
+  aliases?: string[];
+  subcommands?: Command[];
+  action?: (ctx: CommandContext) => Promise<void> | void;
+  options?: Option[];
+}
+
+interface Option {
+  name: string;
+  short?: string;
+  description: string;
+  type?: "string" | "boolean" | "number";
+  default?: unknown;
+  required?: boolean;
+}
+
+class CLI {
+  private commands: Map<string, Command> = new Map();
+  private globalOptions: Option[] = [
+    {
+      name: "help",
+      short: "h",
+      description: "Show help",
+      type: "boolean",
+    },
+    {
+      name: "version",
+      short: "v",
+      description: "Show version",
+      type: "boolean",
+    },
+    {
+      name: "config",
+      short: "c",
+      description: "Path to configuration file",
+      type: "string",
+    },
+    {
+      name: "verbose",
+      description: "Enable verbose logging",
+      type: "boolean",
+    },
+    {
+      name: "log-level",
+      description: "Set log level (debug, info, warn, error)",
+      type: "string",
+      default: "info",
+    },
+  ];
+
+  constructor(private name: string, private description: string) {}
+
+  command(cmd: Command): this {
+    this.commands.set(cmd.name, cmd);
+    if (cmd.aliases) {
+      for (const alias of cmd.aliases) {
+        this.commands.set(alias, cmd);
+      }
+    }
+    return this;
+  }
+
+  async run(args = Deno.args): Promise<void> {
+    const flags = parse(args, {
+      boolean: this.getBooleanFlags(),
+      string: this.getStringFlags(),
+      alias: this.getAliases(),
+      default: this.getDefaults(),
+      stopEarly: true,
+      unknown: () => true,
+    });
+
+    if (flags.version || flags.v) {
+      console.log(`${this.name} v${VERSION}`);
+      return;
+    }
+
+    const commandName = flags._[0]?.toString() || "";
+    
+    if (!commandName || flags.help || flags.h) {
+      this.showHelp();
+      return;
+    }
+
+    const command = this.commands.get(commandName);
+    if (!command) {
+      console.error(red(`Unknown command: ${commandName}`));
+      console.log(`Run "${this.name} help" for available commands`);
+      Deno.exit(1);
+    }
+
+    const ctx: CommandContext = {
+      args: flags._.slice(1).map(String),
+      flags: flags as Record<string, unknown>,
+      config: await this.loadConfig(flags.config as string),
+    };
+
+    try {
+      if (command.action) {
+        await command.action(ctx);
+      } else {
+        console.log(yellow(`Command '${commandName}' has no action defined`));
+      }
+    } catch (error) {
+      console.error(red(`Error executing command '${commandName}':`), (error as Error).message);
+      if (flags.verbose) {
+        console.error(error);
+      }
+      Deno.exit(1);
+    }
+  }
+
+  private async loadConfig(configPath?: string): Promise<Record<string, unknown> | undefined> {
+    const path = configPath || "claude-flow.config.json";
+    try {
+      const content = await Deno.readTextFile(path);
+      return JSON.parse(content);
+    } catch {
+      return undefined;
+    }
+  }
+
+  private getBooleanFlags(): string[] {
+    const flags: string[] = [];
+    for (const opt of [...this.globalOptions, ...this.getAllOptions()]) {
+      if (opt.type === "boolean") {
+        flags.push(opt.name);
+        if (opt.short) flags.push(opt.short);
+      }
+    }
+    return flags;
+  }
+
+  private getStringFlags(): string[] {
+    const flags: string[] = [];
+    for (const opt of [...this.globalOptions, ...this.getAllOptions()]) {
+      if (opt.type === "string" || opt.type === "number") {
+        flags.push(opt.name);
+        if (opt.short) flags.push(opt.short);
+      }
+    }
+    return flags;
+  }
+
+  private getAliases(): Record<string, string> {
+    const aliases: Record<string, string> = {};
+    for (const opt of [...this.globalOptions, ...this.getAllOptions()]) {
+      if (opt.short) {
+        aliases[opt.short] = opt.name;
+      }
+    }
+    return aliases;
+  }
+
+  private getDefaults(): Record<string, unknown> {
+    const defaults: Record<string, unknown> = {};
+    for (const opt of [...this.globalOptions, ...this.getAllOptions()]) {
+      if (opt.default !== undefined) {
+        defaults[opt.name] = opt.default;
+      }
+    }
+    return defaults;
+  }
+
+  private getAllOptions(): Option[] {
+    const options: Option[] = [];
+    for (const cmd of this.commands.values()) {
+      if (cmd.options) {
+        options.push(...cmd.options);
+      }
+    }
+    return options;
+  }
+
+  private showHelp(): void {
+    console.log(`
+${bold(blue(`🧠 ${this.name} v${VERSION}`))} - ${this.description}
+
+${bold("USAGE:")}
+  ${this.name} [COMMAND] [OPTIONS]
+
+${bold("COMMANDS:")}
+${this.formatCommands()}
+
+${bold("GLOBAL OPTIONS:")}
+${this.formatOptions(this.globalOptions)}
+
+${bold("EXAMPLES:")}
+  ${this.name} start                                    # Start orchestrator
+  ${this.name} agent spawn researcher --name "Bot"     # Spawn research agent
+  ${this.name} task create research "Analyze data"     # Create task
+  ${this.name} config init                             # Initialize config
+  ${this.name} status                                  # Show system status
+
+For more detailed help on specific commands, use:
+  ${this.name} [COMMAND] --help
+
+Documentation: https://github.com/ruvnet/claude-code-flow
+Issues: https://github.com/ruvnet/claude-code-flow/issues
+
+Created by rUv - Built with ❤️ for the Claude community
+`);
+  }
+
+  private formatCommands(): string {
+    const commands = Array.from(new Set(this.commands.values()));
+    return commands
+      .map(cmd => `  ${cmd.name.padEnd(20)} ${cmd.description}`)
+      .join("\n");
+  }
+
+  private formatOptions(options: Option[]): string {
+    return options
+      .map(opt => {
+        const flags = opt.short ? `-${opt.short}, --${opt.name}` : `    --${opt.name}`;
+        return `  ${flags.padEnd(25)} ${opt.description}`;
+      })
+      .join("\n");
+  }
+}
+
+// Helper functions
+function success(message: string): void {
+  console.log(green(`✅ ${message}`));
+}
+
+function error(message: string): void {
+  console.error(red(`❌ ${message}`));
+}
+
+function warning(message: string): void {
+  console.warn(yellow(`⚠️  ${message}`));
+}
+
+function info(message: string): void {
+  console.log(blue(`ℹ️  ${message}`));
+}
+
+// Export for use in other modules
+export { CLI, success, error, warning, info };
+export type { Command, CommandContext, Option };
+
+// Main CLI setup if running directly
+if (import.meta.main) {
+  const cli = new CLI("claude-flow", "Advanced AI Agent Orchestration System");
+
+  // Import and register all commands
+  const { setupCommands } = await import("./commands/index.ts");
+  setupCommands(cli);
+
+  // Run the CLI
+  await cli.run();
+}

package/src/cli/commands/agent.ts

@@ -0,0 +1,83 @@
+/**
+ * Agent management commands
+ */
+
+import { Command } from '@cliffy/command';
+import { Table } from '@cliffy/table';
+import { colors } from '@cliffy/ansi/colors';
+import { AgentProfile } from '../../utils/types.ts';
+import { generateId } from '../../utils/helpers.ts';
+
+export const agentCommand = new Command()
+  .description('Manage Claude-Flow agents')
+  .action(() => {
+    agentCommand.showHelp();
+  })
+  .command('list', new Command()
+    .description('List all agents')
+    .action(async () => {
+      // In a real implementation, this would connect to the running orchestrator
+      console.log(colors.yellow('Agent listing requires a running Claude-Flow instance'));
+    }),
+  )
+  .command('spawn', new Command()
+    .description('Spawn a new agent')
+    .arguments('<type:string>')
+    .option('-n, --name <name:string>', 'Agent name')
+    .option('-p, --priority <priority:number>', 'Agent priority', { default: 0 })
+    .option('-m, --max-tasks <max:number>', 'Maximum concurrent tasks', { default: 5 })
+    .option('--system-prompt <prompt:string>', 'Custom system prompt')
+    .action(async (options: any, type: string) => {
+      const profile: AgentProfile = {
+        id: generateId('agent'),
+        name: options.name || `${type}-agent`,
+        type: type as any,
+        capabilities: getCapabilitiesForType(type),
+        systemPrompt: options.systemPrompt || getDefaultPromptForType(type),
+        maxConcurrentTasks: options.maxTasks,
+        priority: options.priority,
+      };
+
+      console.log(colors.green('Agent profile created:'));
+      console.log(JSON.stringify(profile, null, 2));
+      console.log(colors.yellow('\nTo spawn this agent, ensure Claude-Flow is running'));
+    }),
+  )
+  .command('terminate', new Command()
+    .description('Terminate an agent')
+    .arguments('<agent-id:string>')
+    .action(async (options: any, agentId: string) => {
+      console.log(colors.yellow(`Terminating agent ${agentId} requires a running Claude-Flow instance`));
+    }),
+  )
+  .command('info', new Command()
+    .description('Get information about an agent')
+    .arguments('<agent-id:string>')
+    .action(async (options: any, agentId: string) => {
+      console.log(colors.yellow(`Agent info requires a running Claude-Flow instance`));
+    }),
+  );
+
+function getCapabilitiesForType(type: string): string[] {
+  const capabilities: Record<string, string[]> = {
+    coordinator: ['task-assignment', 'planning', 'delegation'],
+    researcher: ['web-search', 'information-gathering', 'analysis'],
+    implementer: ['code-generation', 'file-manipulation', 'testing'],
+    analyst: ['data-analysis', 'pattern-recognition', 'reporting'],
+    custom: ['user-defined'],
+  };
+
+  return capabilities[type] || capabilities.custom;
+}
+
+function getDefaultPromptForType(type: string): string {
+  const prompts: Record<string, string> = {
+    coordinator: 'You are a coordination agent responsible for planning and delegating tasks.',
+    researcher: 'You are a research agent specialized in gathering and analyzing information.',
+    implementer: 'You are an implementation agent focused on writing code and creating solutions.',
+    analyst: 'You are an analysis agent that identifies patterns and generates insights.',
+    custom: 'You are a custom agent. Follow the user\'s instructions.',
+  };
+
+  return prompts[type] || prompts.custom;
+}