@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/swarm/coordinator.d.ts

@@ -1,86 +0,0 @@
-/**
- * Swarm Coordinator - Orchestrates multiple workers executing tasks
- */
-import { EventEmitter } from 'events';
-import type { SwarmTask, CoordinatorOptions, SwarmResult, SwarmEventMap } from './types.js';
-export declare class SwarmCoordinator extends EventEmitter {
-    private options;
-    private taskQueue;
-    private workerPool;
-    private retryPolicy;
-    private running;
-    private startTime;
-    private aborted;
-    constructor(options?: CoordinatorOptions);
-    /**
-     * Add a single task
-     */
-    addTask(task: SwarmTask): void;
-    /**
-     * Add multiple tasks
-     */
-    addTasks(tasks: SwarmTask[]): void;
-    /**
-     * Get next task from queue
-     */
-    getTask(): SwarmTask | null;
-    /**
-     * Peek at next task
-     */
-    peekTask(): SwarmTask | null;
-    /**
-     * Get all workers status
-     */
-    getAllWorkers(): import("./types.js").WorkerStatus[];
-    /**
-     * Get worker status by ID
-     */
-    getWorkerStatus(id: string): import("./types.js").WorkerStatus | undefined;
-    /**
-     * Stop the swarm gracefully
-     */
-    stop(): void;
-    /**
-     * Abort immediately
-     */
-    abort(): void;
-    /**
-     * Run the swarm
-     */
-    run(concurrency?: number): Promise<SwarmResult>;
-    /**
-     * Main processing loop
-     */
-    private processLoop;
-    /**
-     * Execute a single task on a worker
-     */
-    private executeTask;
-    /**
-     * Sleep helper
-     */
-    private sleep;
-    /**
-     * Get queue statistics
-     */
-    getStats(): {
-        total: number;
-        pending: number;
-        running: number;
-        completed: number;
-        failed: number;
-    };
-    /**
-     * Check if swarm is running
-     */
-    isRunning(): boolean;
-    /**
-     * Type-safe event emitter methods
-     */
-    on<K extends keyof SwarmEventMap>(event: K, listener: SwarmEventMap[K]): this;
-    emit<K extends keyof SwarmEventMap>(event: K, ...args: Parameters<SwarmEventMap[K]>): boolean;
-}
-/**
- * Create a swarm coordinator
- */
-export declare function createSwarmCoordinator(options?: CoordinatorOptions): SwarmCoordinator;

package/dist/swarm/coordinator.js

@@ -1,257 +0,0 @@
-/**
- * Swarm Coordinator - Orchestrates multiple workers executing tasks
- */
-import { EventEmitter } from 'events';
-import { DEFAULT_COORDINATOR_OPTIONS, DEFAULT_RETRY_POLICY } from './types.js';
-import { TaskQueue } from './task.js';
-import { WorkerPool } from './worker.js';
-export class SwarmCoordinator extends EventEmitter {
-    options;
-    taskQueue;
-    workerPool;
-    retryPolicy;
-    running = false;
-    startTime = 0;
-    aborted = false;
-    constructor(options = {}) {
-        super();
-        this.options = {
-            ...DEFAULT_COORDINATOR_OPTIONS,
-            ...options,
-            retryPolicy: {
-                ...DEFAULT_RETRY_POLICY,
-                ...options.retryPolicy,
-            },
-        };
-        this.retryPolicy = this.options.retryPolicy;
-        this.taskQueue = new TaskQueue();
-        this.workerPool = new WorkerPool(this.options.concurrency, {
-            cwd: this.options.cwd,
-            yolo: this.options.yolo,
-            timeout: this.options.timeout,
-        });
-    }
-    /**
-     * Add a single task
-     */
-    addTask(task) {
-        this.taskQueue.addTask(task);
-    }
-    /**
-     * Add multiple tasks
-     */
-    addTasks(tasks) {
-        this.taskQueue.addTasks(tasks);
-    }
-    /**
-     * Get next task from queue
-     */
-    getTask() {
-        return this.taskQueue.getNextTask();
-    }
-    /**
-     * Peek at next task
-     */
-    peekTask() {
-        return this.taskQueue.peekNextTask();
-    }
-    /**
-     * Get all workers status
-     */
-    getAllWorkers() {
-        return this.workerPool.getAllWorkers().map(w => w.getStatus());
-    }
-    /**
-     * Get worker status by ID
-     */
-    getWorkerStatus(id) {
-        return this.workerPool.getWorkerById(id)?.getStatus();
-    }
-    /**
-     * Stop the swarm gracefully
-     */
-    stop() {
-        this.running = false;
-    }
-    /**
-     * Abort immediately
-     */
-    abort() {
-        this.aborted = true;
-        this.running = false;
-        this.workerPool.killAll();
-    }
-    /**
-     * Run the swarm
-     */
-    async run(concurrency) {
-        if (concurrency !== undefined) {
-            this.options.concurrency = concurrency;
-            this.workerPool = new WorkerPool(concurrency, {
-                cwd: this.options.cwd,
-                yolo: this.options.yolo,
-                timeout: this.options.timeout,
-            });
-        }
-        this.running = true;
-        this.aborted = false;
-        this.startTime = Date.now();
-        // Skip tasks blocked by failed dependencies
-        const skipped = this.taskQueue.skipBlockedTasks();
-        for (const taskId of skipped) {
-            const task = this.taskQueue.getTask(taskId);
-            if (task) {
-                this.emit('task:fail', task, new Error('Blocked by failed dependency'));
-            }
-        }
-        // Process tasks
-        await this.processLoop();
-        // Mark as no longer running
-        this.running = false;
-        // Build result
-        const stats = this.taskQueue.getStats();
-        const results = this.taskQueue.getResults();
-        const failures = this.taskQueue.getFailures();
-        const duration = Date.now() - this.startTime;
-        const result = {
-            total: stats.total,
-            completed: stats.completed,
-            failed: stats.failed,
-            skipped: skipped.length,
-            duration,
-            successRate: stats.total > 0 ? stats.completed / stats.total : 0,
-            results,
-            failedTasks: failures,
-        };
-        this.emit('swarm:complete', result);
-        return result;
-    }
-    /**
-     * Main processing loop
-     */
-    async processLoop() {
-        const activePromises = new Map();
-        while (this.running && !this.aborted) {
-            // Check if done
-            if (this.taskQueue.isDone() && activePromises.size === 0) {
-                break;
-            }
-            // Skip blocked tasks
-            const skipped = this.taskQueue.skipBlockedTasks();
-            for (const taskId of skipped) {
-                const task = this.taskQueue.getTask(taskId);
-                if (task) {
-                    this.emit('task:fail', task, new Error('Blocked by failed dependency'));
-                }
-            }
-            // Try to start new tasks
-            while (this.workerPool.getAvailableCount() > 0) {
-                const task = this.taskQueue.getNextTask();
-                if (!task)
-                    break;
-                const worker = this.workerPool.getWorker();
-                if (!worker) {
-                    // No worker available, put task back
-                    this.taskQueue.addTask(task);
-                    break;
-                }
-                // Start task execution
-                const promise = this.executeTask(worker, task);
-                activePromises.set(task.id, promise);
-                promise.finally(() => {
-                    activePromises.delete(task.id);
-                });
-            }
-            // Wait a bit before checking again
-            if (activePromises.size > 0) {
-                await Promise.race([
-                    ...activePromises.values(),
-                    this.sleep(100),
-                ]);
-            }
-            else if (this.taskQueue.hasWork()) {
-                // Have work but no available workers, wait
-                await this.sleep(100);
-            }
-            else {
-                break;
-            }
-        }
-        // Wait for remaining tasks to complete
-        if (activePromises.size > 0) {
-            await Promise.all(activePromises.values());
-        }
-    }
-    /**
-     * Execute a single task on a worker
-     */
-    async executeTask(worker, task) {
-        const attempt = this.taskQueue.getAttempts(task.id) + 1;
-        this.emit('task:start', task, worker.id);
-        if (attempt > 1) {
-            this.emit('task:retry', task, attempt);
-        }
-        try {
-            const result = await worker.execute(task);
-            if (result.success) {
-                const taskResult = {
-                    task,
-                    workerId: worker.id,
-                    result,
-                };
-                this.taskQueue.completeTask(task.id, taskResult);
-                this.emit('task:complete', task, result);
-            }
-            else {
-                const willRetry = this.taskQueue.failTask(task.id, result.error || 'Unknown error', this.retryPolicy.maxRetries);
-                if (!willRetry) {
-                    this.emit('task:fail', task, new Error(result.error || 'Max retries exceeded'));
-                }
-            }
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            const willRetry = this.taskQueue.failTask(task.id, errorMsg, this.retryPolicy.maxRetries);
-            if (!willRetry) {
-                this.emit('task:fail', task, error instanceof Error ? error : new Error(errorMsg));
-            }
-        }
-        finally {
-            // Release worker back to pool
-            this.workerPool.releaseWorker(worker);
-        }
-    }
-    /**
-     * Sleep helper
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Get queue statistics
-     */
-    getStats() {
-        return this.taskQueue.getStats();
-    }
-    /**
-     * Check if swarm is running
-     */
-    isRunning() {
-        return this.running;
-    }
-    /**
-     * Type-safe event emitter methods
-     */
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    emit(event, ...args) {
-        return super.emit(event, ...args);
-    }
-}
-/**
- * Create a swarm coordinator
- */
-export function createSwarmCoordinator(options) {
-    return new SwarmCoordinator(options);
-}

package/dist/swarm/index.d.ts

@@ -1,28 +0,0 @@
-/**
- * Swarm Module - Coordinate multiple Simple-CLI agents
- *
- * @example
- * ```typescript
- * import { SwarmCoordinator } from 'simplecli/swarm';
- *
- * const coordinator = new SwarmCoordinator({
- *   cwd: '/path/to/repo',
- *   concurrency: 4,
- *   yolo: true,
- * });
- *
- * coordinator.addTasks([
- *   { id: 'task1', type: 'implement', description: '...', scope: {}, priority: 1, timeout: 300000, retries: 2 },
- *   { id: 'task2', type: 'test', description: '...', scope: {}, priority: 2, timeout: 180000, retries: 1 },
- * ]);
- *
- * const result = await coordinator.run();
- * console.log(`Completed: ${result.completed}/${result.total}`);
- * ```
- */
-export type { SwarmTask, TaskScope, TaskType, Priority, WorkerStatus, WorkerState, WorkerResult, TaskResult, FailedTask, SwarmResult, CoordinatorOptions, RetryPolicy, SwarmEventMap, } from './types.js';
-export { swarmTaskSchema, taskScopeSchema, DEFAULT_RETRY_POLICY, DEFAULT_COORDINATOR_OPTIONS, } from './types.js';
-export { TaskQueue } from './task.js';
-export { Worker, WorkerPool } from './worker.js';
-export type { WorkerOptions } from './worker.js';
-export { SwarmCoordinator, createSwarmCoordinator } from './coordinator.js';

package/dist/swarm/index.js

@@ -1,29 +0,0 @@
-/**
- * Swarm Module - Coordinate multiple Simple-CLI agents
- *
- * @example
- * ```typescript
- * import { SwarmCoordinator } from 'simplecli/swarm';
- *
- * const coordinator = new SwarmCoordinator({
- *   cwd: '/path/to/repo',
- *   concurrency: 4,
- *   yolo: true,
- * });
- *
- * coordinator.addTasks([
- *   { id: 'task1', type: 'implement', description: '...', scope: {}, priority: 1, timeout: 300000, retries: 2 },
- *   { id: 'task2', type: 'test', description: '...', scope: {}, priority: 2, timeout: 180000, retries: 1 },
- * ]);
- *
- * const result = await coordinator.run();
- * console.log(`Completed: ${result.completed}/${result.total}`);
- * ```
- */
-export { swarmTaskSchema, taskScopeSchema, DEFAULT_RETRY_POLICY, DEFAULT_COORDINATOR_OPTIONS, } from './types.js';
-// Task Queue
-export { TaskQueue } from './task.js';
-// Worker
-export { Worker, WorkerPool } from './worker.js';
-// Coordinator
-export { SwarmCoordinator, createSwarmCoordinator } from './coordinator.js';

package/dist/swarm/task.d.ts

@@ -1,104 +0,0 @@
-/**
- * Task Queue - Priority-based task queue with dependency tracking
- */
-import type { SwarmTask, TaskResult, FailedTask } from './types.js';
-export declare class TaskQueue {
-    private tasks;
-    private pending;
-    private running;
-    private completed;
-    private failed;
-    private results;
-    private failures;
-    private attempts;
-    /**
-     * Add a task to the queue
-     */
-    addTask(task: SwarmTask): void;
-    /**
-     * Add multiple tasks
-     */
-    addTasks(tasks: SwarmTask[]): void;
-    /**
-     * Get next available task (respects dependencies and priorities)
-     */
-    getNextTask(): SwarmTask | null;
-    /**
-     * Get all tasks that are ready to run
-     */
-    getAvailableTasks(): SwarmTask[];
-    /**
-     * Check if a task's dependencies are all completed
-     */
-    areDependenciesMet(task: SwarmTask): boolean;
-    /**
-     * Mark a task as completed
-     */
-    completeTask(taskId: string, result: TaskResult): void;
-    /**
-     * Mark a task as failed (may retry)
-     */
-    failTask(taskId: string, error: string, maxRetries: number): boolean;
-    /**
-     * Get number of attempts for a task
-     */
-    getAttempts(taskId: string): number;
-    /**
-     * Peek at next task without removing it
-     */
-    peekNextTask(): SwarmTask | null;
-    /**
-     * Check if all tasks are done (completed or failed)
-     */
-    isDone(): boolean;
-    /**
-     * Check if there's any work to do
-     */
-    hasWork(): boolean;
-    /**
-     * Check if any tasks are currently running
-     */
-    hasRunning(): boolean;
-    /**
-     * Get queue statistics
-     */
-    getStats(): {
-        total: number;
-        pending: number;
-        running: number;
-        completed: number;
-        failed: number;
-    };
-    /**
-     * Get all results
-     */
-    getResults(): TaskResult[];
-    /**
-     * Get all failures
-     */
-    getFailures(): FailedTask[];
-    /**
-     * Get a specific task
-     */
-    getTask(taskId: string): SwarmTask | undefined;
-    /**
-     * Get all tasks
-     */
-    getAllTasks(): SwarmTask[];
-    /**
-     * Clear the queue
-     */
-    clear(): void;
-    /**
-     * Cancel a pending task
-     */
-    cancelTask(taskId: string): boolean;
-    /**
-     * Check if a task is blocked by failed dependencies
-     */
-    isBlocked(taskId: string): boolean;
-    /**
-     * Skip tasks that are blocked by failed dependencies
-     */
-    skipBlockedTasks(): string[];
-}