claude-flow 1.0.0

package/src/core/event-bus.ts

@@ -0,0 +1,186 @@
+/**
+ * Event bus implementation for Claude-Flow
+ */
+
+import { SystemEvents, EventMap } from '../utils/types.ts';
+import { TypedEventEmitter } from '../utils/helpers.ts';
+
+export interface IEventBus {
+  emit(event: string, data?: unknown): void;
+  on(event: string, handler: (data: unknown) => void): void;
+  off(event: string, handler: (data: unknown) => void): void;
+  once(event: string, handler: (data: unknown) => void): void;
+}
+
+/**
+ * Internal typed event bus
+ */
+class TypedEventBus extends TypedEventEmitter<EventMap> {
+  private eventCounts = new Map<keyof EventMap, number>();
+  private lastEventTimes = new Map<keyof EventMap, number>();
+  private debug: boolean;
+
+  constructor(debug = false) {
+    super();
+    this.debug = debug;
+  }
+
+  /**
+   * Emits an event with logging
+   */
+  override emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void {
+    if (this.debug) {
+      console.debug(`[EventBus] Emitting event: ${String(event)}`, data);
+    }
+    
+    // Track event metrics
+    const count = this.eventCounts.get(event) || 0;
+    this.eventCounts.set(event, count + 1);
+    this.lastEventTimes.set(event, Date.now());
+    
+    super.emit(event, data);
+  }
+
+  /**
+   * Get event statistics
+   */
+  getEventStats(): { event: string; count: number; lastEmitted: Date | null }[] {
+    const stats: { event: string; count: number; lastEmitted: Date | null }[] = [];
+    
+    for (const [event, count] of this.eventCounts.entries()) {
+      const lastTime = this.lastEventTimes.get(event);
+      stats.push({
+        event: String(event),
+        count,
+        lastEmitted: lastTime ? new Date(lastTime) : null,
+      });
+    }
+    
+    return stats.sort((a, b) => b.count - a.count);
+  }
+
+  /**
+   * Reset event statistics
+   */
+  resetStats(): void {
+    this.eventCounts.clear();
+    this.lastEventTimes.clear();
+  }
+}
+
+/**
+ * Global event bus for system-wide communication
+ */
+export class EventBus implements IEventBus {
+  private static instance: EventBus;
+  private typedBus: TypedEventBus;
+
+  private constructor(debug = false) {
+    this.typedBus = new TypedEventBus(debug);
+  }
+
+  /**
+   * Gets the singleton instance of the event bus
+   */
+  static getInstance(debug = false): EventBus {
+    if (!EventBus.instance) {
+      EventBus.instance = new EventBus(debug);
+    }
+    return EventBus.instance;
+  }
+
+  /**
+   * Emits an event
+   */
+  emit(event: string, data?: unknown): void {
+    // Type-safe emission for known events
+    if (event in SystemEvents) {
+      this.typedBus.emit(event as keyof EventMap, data as any);
+    } else {
+      // For custom events, emit as-is
+      this.typedBus.emit(event as any, data as any);
+    }
+  }
+
+  /**
+   * Registers an event handler
+   */
+  on(event: string, handler: (data: unknown) => void): void {
+    this.typedBus.on(event as any, handler);
+  }
+
+  /**
+   * Removes an event handler
+   */
+  off(event: string, handler: (data: unknown) => void): void {
+    this.typedBus.off(event as any, handler);
+  }
+
+  /**
+   * Registers a one-time event handler
+   */
+  once(event: string, handler: (data: unknown) => void): void {
+    this.typedBus.once(event as any, handler);
+  }
+
+  /**
+   * Waits for an event to occur
+   */
+  async waitFor(event: string, timeoutMs?: number): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      const handler = (data: unknown) => {
+        if (timer) clearTimeout(timer);
+        resolve(data);
+      };
+
+      let timer: number | undefined;
+      if (timeoutMs) {
+        timer = setTimeout(() => {
+          this.off(event, handler);
+          reject(new Error(`Timeout waiting for event: ${event}`));
+        }, timeoutMs);
+      }
+
+      this.once(event, handler);
+    });
+  }
+
+  /**
+   * Creates a filtered event listener
+   */
+  onFiltered(
+    event: string,
+    filter: (data: unknown) => boolean,
+    handler: (data: unknown) => void,
+  ): void {
+    this.on(event, (data) => {
+      if (filter(data)) {
+        handler(data);
+      }
+    });
+  }
+
+  /**
+   * Get event statistics
+   */
+  getEventStats(): { event: string; count: number; lastEmitted: Date | null }[] {
+    return this.typedBus.getEventStats();
+  }
+
+  /**
+   * Reset event statistics
+   */
+  resetStats(): void {
+    this.typedBus.resetStats();
+  }
+
+  /**
+   * Remove all listeners for an event
+   */
+  removeAllListeners(event?: string): void {
+    this.typedBus.removeAllListeners(event as any);
+  }
+}
+
+// Export singleton instance
+export const eventBus = EventBus.getInstance();

package/src/core/json-persistence.ts

@@ -0,0 +1,183 @@
+/**
+ * JSON-based persistence layer for Claude-Flow
+ */
+
+import { join } from "https://deno.land/std@0.224.0/path/mod.ts";
+import { ensureDir, exists } from "https://deno.land/std@0.224.0/fs/mod.ts";
+
+export interface PersistedAgent {
+  id: string;
+  type: string;
+  name: string;
+  status: string;
+  capabilities: string[];
+  systemPrompt: string;
+  maxConcurrentTasks: number;
+  priority: number;
+  createdAt: number;
+}
+
+export interface PersistedTask {
+  id: string;
+  type: string;
+  description: string;
+  status: string;
+  priority: number;
+  dependencies: string[];
+  metadata: Record<string, unknown>;
+  assignedAgent?: string;
+  progress: number;
+  error?: string;
+  createdAt: number;
+  completedAt?: number;
+}
+
+interface PersistenceData {
+  agents: PersistedAgent[];
+  tasks: PersistedTask[];
+  lastUpdated: number;
+}
+
+export class JsonPersistenceManager {
+  private dataPath: string;
+  private data: PersistenceData;
+
+  constructor(dataDir: string = "./memory") {
+    this.dataPath = join(dataDir, "claude-flow-data.json");
+    this.data = {
+      agents: [],
+      tasks: [],
+      lastUpdated: Date.now(),
+    };
+  }
+
+  async initialize(): Promise<void> {
+    // Ensure directory exists
+    await ensureDir(join(this.dataPath, ".."));
+    
+    // Load existing data if available
+    if (await exists(this.dataPath)) {
+      try {
+        const content = await Deno.readTextFile(this.dataPath);
+        this.data = JSON.parse(content);
+      } catch (error) {
+        console.error("Failed to load persistence data:", error);
+        // Keep default empty data
+      }
+    }
+  }
+
+  private async save(): Promise<void> {
+    this.data.lastUpdated = Date.now();
+    await Deno.writeTextFile(this.dataPath, JSON.stringify(this.data, null, 2));
+  }
+
+  // Agent operations
+  async saveAgent(agent: PersistedAgent): Promise<void> {
+    // Remove existing agent if updating
+    this.data.agents = this.data.agents.filter(a => a.id !== agent.id);
+    this.data.agents.push(agent);
+    await this.save();
+  }
+
+  async getAgent(id: string): Promise<PersistedAgent | null> {
+    return this.data.agents.find(a => a.id === id) || null;
+  }
+
+  async getActiveAgents(): Promise<PersistedAgent[]> {
+    return this.data.agents.filter(a => a.status === 'active' || a.status === 'idle');
+  }
+
+  async getAllAgents(): Promise<PersistedAgent[]> {
+    return this.data.agents;
+  }
+
+  async updateAgentStatus(id: string, status: string): Promise<void> {
+    const agent = this.data.agents.find(a => a.id === id);
+    if (agent) {
+      agent.status = status;
+      await this.save();
+    }
+  }
+
+  // Task operations
+  async saveTask(task: PersistedTask): Promise<void> {
+    // Remove existing task if updating
+    this.data.tasks = this.data.tasks.filter(t => t.id !== task.id);
+    this.data.tasks.push(task);
+    await this.save();
+  }
+
+  async getTask(id: string): Promise<PersistedTask | null> {
+    return this.data.tasks.find(t => t.id === id) || null;
+  }
+
+  async getActiveTasks(): Promise<PersistedTask[]> {
+    return this.data.tasks.filter(t => 
+      t.status === 'pending' || 
+      t.status === 'in_progress' || 
+      t.status === 'assigned'
+    );
+  }
+
+  async getAllTasks(): Promise<PersistedTask[]> {
+    return this.data.tasks;
+  }
+
+  async updateTaskStatus(id: string, status: string, assignedAgent?: string): Promise<void> {
+    const task = this.data.tasks.find(t => t.id === id);
+    if (task) {
+      task.status = status;
+      if (assignedAgent !== undefined) {
+        task.assignedAgent = assignedAgent;
+      }
+      if (status === 'completed') {
+        task.completedAt = Date.now();
+      }
+      await this.save();
+    }
+  }
+
+  async updateTaskProgress(id: string, progress: number): Promise<void> {
+    const task = this.data.tasks.find(t => t.id === id);
+    if (task) {
+      task.progress = progress;
+      await this.save();
+    }
+  }
+
+  // Statistics
+  async getStats(): Promise<{
+    totalAgents: number;
+    activeAgents: number;
+    totalTasks: number;
+    pendingTasks: number;
+    completedTasks: number;
+  }> {
+    const activeAgents = this.data.agents.filter(a => 
+      a.status === 'active' || a.status === 'idle'
+    ).length;
+    
+    const pendingTasks = this.data.tasks.filter(t => 
+      t.status === 'pending' || 
+      t.status === 'in_progress' || 
+      t.status === 'assigned'
+    ).length;
+    
+    const completedTasks = this.data.tasks.filter(t => 
+      t.status === 'completed'
+    ).length;
+    
+    return {
+      totalAgents: this.data.agents.length,
+      activeAgents,
+      totalTasks: this.data.tasks.length,
+      pendingTasks,
+      completedTasks,
+    };
+  }
+
+  close(): void {
+    // No-op for JSON persistence
+  }
+}

package/src/core/logger.ts

@@ -0,0 +1,262 @@
+/**
+ * Logging infrastructure for Claude-Flow
+ */
+
+import { LoggingConfig } from '../utils/types.ts';
+import { formatBytes } from '../utils/helpers.ts';
+
+export interface ILogger {
+  debug(message: string, meta?: unknown): void;
+  info(message: string, meta?: unknown): void;
+  warn(message: string, meta?: unknown): void;
+  error(message: string, error?: unknown): void;
+  configure(config: LoggingConfig): Promise<void>;
+}
+
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+}
+
+interface LogEntry {
+  timestamp: string;
+  level: string;
+  message: string;
+  context: Record<string, unknown>;
+  data?: unknown;
+  error?: unknown;
+}
+
+/**
+ * Logger implementation with context support
+ */
+export class Logger implements ILogger {
+  private static instance: Logger;
+  private config: LoggingConfig;
+  private context: Record<string, unknown>;
+  private fileHandle?: Deno.FsFile;
+  private currentFileSize = 0;
+  private currentFileIndex = 0;
+
+  constructor(
+    config: LoggingConfig = {
+      level: 'info',
+      format: 'json',
+      destination: 'console',
+    },
+    context: Record<string, unknown> = {},
+  ) {
+    this.config = config;
+    this.context = context;
+  }
+
+  /**
+   * Gets the singleton instance of the logger
+   */
+  static getInstance(config?: LoggingConfig): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger(config);
+    }
+    return Logger.instance;
+  }
+
+  /**
+   * Updates logger configuration
+   */
+  async configure(config: LoggingConfig): Promise<void> {
+    this.config = config;
+    
+    // Reset file handle if destination changed
+    if (this.fileHandle && config.destination !== 'file' && config.destination !== 'both') {
+      await this.fileHandle.close();
+      delete this.fileHandle;
+    }
+  }
+
+  debug(message: string, meta?: unknown): void {
+    this.log(LogLevel.DEBUG, message, meta);
+  }
+
+  info(message: string, meta?: unknown): void {
+    this.log(LogLevel.INFO, message, meta);
+  }
+
+  warn(message: string, meta?: unknown): void {
+    this.log(LogLevel.WARN, message, meta);
+  }
+
+  error(message: string, error?: unknown): void {
+    this.log(LogLevel.ERROR, message, undefined, error);
+  }
+
+  /**
+   * Creates a child logger with additional context
+   */
+  child(context: Record<string, unknown>): Logger {
+    return new Logger(this.config, { ...this.context, ...context });
+  }
+
+  private log(level: LogLevel, message: string, data?: unknown, error?: unknown): void {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level: LogLevel[level],
+      message,
+      context: this.context,
+      data,
+      error,
+    };
+
+    const formatted = this.format(entry);
+
+    if (this.config.destination === 'console' || this.config.destination === 'both') {
+      this.writeToConsole(level, formatted);
+    }
+
+    if (this.config.destination === 'file' || this.config.destination === 'both') {
+      this.writeToFile(formatted);
+    }
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const configLevel = LogLevel[this.config.level.toUpperCase() as keyof typeof LogLevel];
+    return level >= configLevel;
+  }
+
+  private format(entry: LogEntry): string {
+    if (this.config.format === 'json') {
+      return JSON.stringify(entry);
+    }
+
+    // Text format
+    const contextStr = Object.keys(entry.context).length > 0
+      ? ` ${JSON.stringify(entry.context)}`
+      : '';
+    const dataStr = entry.data !== undefined
+      ? ` ${JSON.stringify(entry.data)}`
+      : '';
+    const errorStr = entry.error !== undefined
+      ? entry.error instanceof Error
+        ? `\n  Error: ${entry.error.message}\n  Stack: ${entry.error.stack}`
+        : ` Error: ${JSON.stringify(entry.error)}`
+      : '';
+
+    return `[${entry.timestamp}] ${entry.level} ${entry.message}${contextStr}${dataStr}${errorStr}`;
+  }
+
+  private writeToConsole(level: LogLevel, message: string): void {
+    switch (level) {
+      case LogLevel.DEBUG:
+        console.debug(message);
+        break;
+      case LogLevel.INFO:
+        console.info(message);
+        break;
+      case LogLevel.WARN:
+        console.warn(message);
+        break;
+      case LogLevel.ERROR:
+        console.error(message);
+        break;
+    }
+  }
+
+  private async writeToFile(message: string): Promise<void> {
+    if (!this.config.filePath) {
+      return;
+    }
+
+    try {
+      // Check if we need to rotate the log file
+      if (await this.shouldRotate()) {
+        await this.rotate();
+      }
+
+      // Open file handle if not already open
+      if (!this.fileHandle) {
+        this.fileHandle = await Deno.open(this.config.filePath, {
+          create: true,
+          append: true,
+          write: true,
+        });
+      }
+
+      // Write the message
+      const encoder = new TextEncoder();
+      const data = encoder.encode(message + '\n');
+      await this.fileHandle.write(data);
+      this.currentFileSize += data.length;
+    } catch (error) {
+      console.error('Failed to write to log file:', error);
+    }
+  }
+
+  private async shouldRotate(): Promise<boolean> {
+    if (!this.config.maxFileSize || !this.fileHandle) {
+      return false;
+    }
+
+    try {
+      const stat = await this.fileHandle.stat();
+      return stat.size >= this.config.maxFileSize;
+    } catch {
+      return false;
+    }
+  }
+
+  private async rotate(): Promise<void> {
+    if (!this.config.filePath || !this.config.maxFiles) {
+      return;
+    }
+
+    // Close current file
+    if (this.fileHandle) {
+      await this.fileHandle.close();
+      delete this.fileHandle;
+    }
+
+    // Rename current file
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const rotatedPath = `${this.config.filePath}.${timestamp}`;
+    await Deno.rename(this.config.filePath, rotatedPath);
+
+    // Clean up old files
+    await this.cleanupOldFiles();
+
+    // Reset file size
+    this.currentFileSize = 0;
+  }
+
+  private async cleanupOldFiles(): Promise<void> {
+    if (!this.config.filePath || !this.config.maxFiles) {
+      return;
+    }
+
+    const dir = this.config.filePath.substring(0, this.config.filePath.lastIndexOf('/'));
+    const baseFileName = this.config.filePath.substring(this.config.filePath.lastIndexOf('/') + 1);
+
+    const files: string[] = [];
+    for await (const entry of Deno.readDir(dir)) {
+      if (entry.isFile && entry.name.startsWith(baseFileName + '.')) {
+        files.push(entry.name);
+      }
+    }
+
+    // Sort files by timestamp (newest first)
+    files.sort().reverse();
+
+    // Remove old files
+    const filesToRemove = files.slice(this.config.maxFiles - 1);
+    for (const file of filesToRemove) {
+      await Deno.remove(`${dir}/${file}`);
+    }
+  }
+}
+
+// Export singleton instance
+export const logger = Logger.getInstance();