@stan-chen/simple-cli 0.2.1

package/dist/swarm/task.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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[];
+}

package/dist/swarm/task.js

@@ -0,0 +1,221 @@
+/**
+ * Task Queue - Priority-based task queue with dependency tracking
+ */
+import { swarmTaskSchema } from './types.js';
+export class TaskQueue {
+    tasks = new Map();
+    pending = new Set();
+    running = new Set();
+    completed = new Set();
+    failed = new Set();
+    results = new Map();
+    failures = new Map();
+    attempts = new Map();
+    /**
+     * Add a task to the queue
+     */
+    addTask(task) {
+        const validated = swarmTaskSchema.parse(task);
+        this.tasks.set(validated.id, validated);
+        this.pending.add(validated.id);
+        this.attempts.set(validated.id, 0);
+    }
+    /**
+     * Add multiple tasks
+     */
+    addTasks(tasks) {
+        for (const task of tasks) {
+            this.addTask(task);
+        }
+    }
+    /**
+     * Get next available task (respects dependencies and priorities)
+     */
+    getNextTask() {
+        const available = this.getAvailableTasks();
+        if (available.length === 0)
+            return null;
+        // Sort by priority (1 = highest)
+        available.sort((a, b) => a.priority - b.priority);
+        const task = available[0];
+        this.pending.delete(task.id);
+        this.running.add(task.id);
+        return task;
+    }
+    /**
+     * Get all tasks that are ready to run
+     */
+    getAvailableTasks() {
+        const available = [];
+        for (const taskId of this.pending) {
+            const task = this.tasks.get(taskId);
+            if (this.areDependenciesMet(task)) {
+                available.push(task);
+            }
+        }
+        return available;
+    }
+    /**
+     * Check if a task's dependencies are all completed
+     */
+    areDependenciesMet(task) {
+        if (!task.dependencies || task.dependencies.length === 0) {
+            return true;
+        }
+        return task.dependencies.every(depId => this.completed.has(depId));
+    }
+    /**
+     * Mark a task as completed
+     */
+    completeTask(taskId, result) {
+        this.running.delete(taskId);
+        this.completed.add(taskId);
+        this.results.set(taskId, result);
+    }
+    /**
+     * Mark a task as failed (may retry)
+     */
+    failTask(taskId, error, maxRetries) {
+        const attempts = (this.attempts.get(taskId) || 0) + 1;
+        this.attempts.set(taskId, attempts);
+        if (attempts < maxRetries) {
+            // Retry: move back to pending
+            this.running.delete(taskId);
+            this.pending.add(taskId);
+            return true; // Will retry
+        }
+        // Max retries exceeded
+        this.running.delete(taskId);
+        this.failed.add(taskId);
+        const task = this.tasks.get(taskId);
+        this.failures.set(taskId, {
+            task,
+            error,
+            attempts,
+        });
+        return false; // No more retries
+    }
+    /**
+     * Get number of attempts for a task
+     */
+    getAttempts(taskId) {
+        return this.attempts.get(taskId) || 0;
+    }
+    /**
+     * Peek at next task without removing it
+     */
+    peekNextTask() {
+        const available = this.getAvailableTasks();
+        if (available.length === 0)
+            return null;
+        available.sort((a, b) => a.priority - b.priority);
+        return available[0];
+    }
+    /**
+     * Check if all tasks are done (completed or failed)
+     */
+    isDone() {
+        return this.pending.size === 0 && this.running.size === 0;
+    }
+    /**
+     * Check if there's any work to do
+     */
+    hasWork() {
+        return this.pending.size > 0 || this.running.size > 0;
+    }
+    /**
+     * Check if any tasks are currently running
+     */
+    hasRunning() {
+        return this.running.size > 0;
+    }
+    /**
+     * Get queue statistics
+     */
+    getStats() {
+        return {
+            total: this.tasks.size,
+            pending: this.pending.size,
+            running: this.running.size,
+            completed: this.completed.size,
+            failed: this.failed.size,
+        };
+    }
+    /**
+     * Get all results
+     */
+    getResults() {
+        return Array.from(this.results.values());
+    }
+    /**
+     * Get all failures
+     */
+    getFailures() {
+        return Array.from(this.failures.values());
+    }
+    /**
+     * Get a specific task
+     */
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    /**
+     * Get all tasks
+     */
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    /**
+     * Clear the queue
+     */
+    clear() {
+        this.tasks.clear();
+        this.pending.clear();
+        this.running.clear();
+        this.completed.clear();
+        this.failed.clear();
+        this.results.clear();
+        this.failures.clear();
+        this.attempts.clear();
+    }
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId) {
+        if (this.pending.has(taskId)) {
+            this.pending.delete(taskId);
+            this.tasks.delete(taskId);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if a task is blocked by failed dependencies
+     */
+    isBlocked(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task || !task.dependencies)
+            return false;
+        return task.dependencies.some(depId => this.failed.has(depId));
+    }
+    /**
+     * Skip tasks that are blocked by failed dependencies
+     */
+    skipBlockedTasks() {
+        const skipped = [];
+        for (const taskId of [...this.pending]) {
+            if (this.isBlocked(taskId)) {
+                this.pending.delete(taskId);
+                this.failed.add(taskId);
+                const task = this.tasks.get(taskId);
+                this.failures.set(taskId, {
+                    task,
+                    error: 'Skipped due to failed dependency',
+                    attempts: 0,
+                });
+                skipped.push(taskId);
+            }
+        }
+        return skipped;
+    }
+}

package/dist/swarm/types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Swarm Types - Type definitions for swarm coordination
+ */
+import { z } from 'zod';
+export type Priority = 1 | 2 | 3;
+export type TaskType = 'implement' | 'test' | 'refactor' | 'review' | 'fix';
+export type WorkerState = 'idle' | 'running' | 'completed' | 'failed';
+export declare const taskScopeSchema: z.ZodObject<{
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    directories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    files?: string[] | undefined;
+    pattern?: string | undefined;
+    directories?: string[] | undefined;
+}, {
+    files?: string[] | undefined;
+    pattern?: string | undefined;
+    directories?: string[] | undefined;
+}>;
+export type TaskScope = z.infer<typeof taskScopeSchema>;
+export declare const swarmTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["implement", "test", "refactor", "review", "fix"]>;
+    description: z.ZodString;
+    scope: z.ZodObject<{
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        directories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        pattern: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        files?: string[] | undefined;
+        pattern?: string | undefined;
+        directories?: string[] | undefined;
+    }, {
+        files?: string[] | undefined;
+        pattern?: string | undefined;
+        directories?: string[] | undefined;
+    }>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    priority: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    retries: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "test" | "refactor" | "review" | "implement" | "fix";
+    timeout: number;
+    description: string;
+    id: string;
+    scope: {
+        files?: string[] | undefined;
+        pattern?: string | undefined;
+        directories?: string[] | undefined;
+    };
+    dependencies: string[];
+    priority: 1 | 2 | 3;
+    retries: number;
+}, {
+    type: "test" | "refactor" | "review" | "implement" | "fix";
+    description: string;
+    id: string;
+    scope: {
+        files?: string[] | undefined;
+        pattern?: string | undefined;
+        directories?: string[] | undefined;
+    };
+    timeout?: number | undefined;
+    dependencies?: string[] | undefined;
+    priority?: 1 | 2 | 3 | undefined;
+    retries?: number | undefined;
+}>;
+export type SwarmTask = z.infer<typeof swarmTaskSchema>;
+export interface WorkerResult {
+    success: boolean;
+    filesChanged: string[];
+    commitHash?: string;
+    error?: string;
+    duration: number;
+    output?: string;
+}
+export interface WorkerStatus {
+    id: string;
+    pid?: number;
+    state: WorkerState;
+    currentTask?: string;
+    startedAt?: number;
+    completedAt?: number;
+    result?: WorkerResult;
+}
+export interface RetryPolicy {
+    maxRetries: number;
+    backoffMs: number;
+    backoffMultiplier: number;
+    maxBackoffMs: number;
+}
+export interface CoordinatorOptions {
+    cwd?: string;
+    concurrency?: number;
+    branch?: string;
+    yolo?: boolean;
+    retryPolicy?: Partial<RetryPolicy>;
+    timeout?: number;
+}
+export interface SwarmResult {
+    total: number;
+    completed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+    successRate: number;
+    results: TaskResult[];
+    failedTasks: FailedTask[];
+}
+export interface TaskResult {
+    task: SwarmTask;
+    workerId: string;
+    result: WorkerResult;
+}
+export interface FailedTask {
+    task: SwarmTask;
+    error: string;
+    attempts: number;
+}
+export type SwarmEventMap = {
+    'task:start': (task: SwarmTask, workerId: string) => void;
+    'task:complete': (task: SwarmTask, result: WorkerResult) => void;
+    'task:fail': (task: SwarmTask, error: Error) => void;
+    'task:retry': (task: SwarmTask, attempt: number) => void;
+    'worker:spawn': (worker: WorkerStatus) => void;
+    'worker:exit': (worker: WorkerStatus, code: number) => void;
+    'swarm:complete': (result: SwarmResult) => void;
+};
+export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+export declare const DEFAULT_COORDINATOR_OPTIONS: Required<CoordinatorOptions>;

package/dist/swarm/types.js

@@ -0,0 +1,37 @@
+/**
+ * Swarm Types - Type definitions for swarm coordination
+ */
+import { z } from 'zod';
+// Task scope schema
+export const taskScopeSchema = z.object({
+    files: z.array(z.string()).optional(),
+    directories: z.array(z.string()).optional(),
+    pattern: z.string().optional(),
+});
+// Task definition schema
+export const swarmTaskSchema = z.object({
+    id: z.string(),
+    type: z.enum(['implement', 'test', 'refactor', 'review', 'fix']),
+    description: z.string(),
+    scope: taskScopeSchema,
+    dependencies: z.array(z.string()).optional().default([]),
+    priority: z.union([z.literal(1), z.literal(2), z.literal(3)]).default(2),
+    timeout: z.number().default(300000), // 5 minutes
+    retries: z.number().default(2),
+});
+// Default retry policy
+export const DEFAULT_RETRY_POLICY = {
+    maxRetries: 3,
+    backoffMs: 1000,
+    backoffMultiplier: 2,
+    maxBackoffMs: 30000,
+};
+// Default coordinator options
+export const DEFAULT_COORDINATOR_OPTIONS = {
+    cwd: process.cwd(),
+    concurrency: 4,
+    branch: 'main',
+    yolo: false,
+    retryPolicy: DEFAULT_RETRY_POLICY,
+    timeout: 600000, // 10 minutes
+};

package/dist/swarm/worker.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Worker - Spawns and manages Simple-CLI worker processes
+ */
+import { EventEmitter } from 'events';
+import type { SwarmTask, WorkerStatus, WorkerResult } from './types.js';
+export interface WorkerOptions {
+    cwd: string;
+    yolo: boolean;
+    timeout: number;
+    env?: Record<string, string>;
+}
+export declare class Worker extends EventEmitter {
+    readonly id: string;
+    private process;
+    private state;
+    private currentTask;
+    private startedAt;
+    private output;
+    private options;
+    constructor(options: WorkerOptions);
+    /**
+     * Get current worker status
+     */
+    getStatus(): WorkerStatus;
+    /**
+     * Execute a task
+     */
+    execute(task: SwarmTask): Promise<WorkerResult>;
+    /**
+     * Build prompt from task
+     */
+    private buildPrompt;
+    /**
+     * Parse changed files from output
+     */
+    private parseChangedFiles;
+    /**
+     * Parse commit hash from output
+     */
+    private parseCommitHash;
+    /**
+     * Kill the worker process
+     */
+    kill(): void;
+    /**
+     * Check if worker is busy
+     */
+    isBusy(): boolean;
+    /**
+     * Check if worker is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Reset worker for reuse
+     */
+    reset(): void;
+    /**
+     * Get task output
+     */
+    getOutput(): string;
+}
+/**
+ * Worker pool for managing multiple workers
+ */
+export declare class WorkerPool {
+    private workers;
+    private inUse;
+    private options;
+    private maxWorkers;
+    constructor(maxWorkers: number, options: WorkerOptions);
+    /**
+     * Get an available worker (or create one if pool not full)
+     */
+    getWorker(): Worker | null;
+    /**
+     * Release a worker back to the pool
+     */
+    releaseWorker(worker: Worker): void;
+    /**
+     * Get all workers
+     */
+    getAllWorkers(): Worker[];
+    /**
+     * Get worker by ID
+     */
+    getWorkerById(id: string): Worker | undefined;
+    /**
+     * Get number of busy workers
+     */
+    getBusyCount(): number;
+    /**
+     * Get number of available workers
+     */
+    getAvailableCount(): number;
+    /**
+     * Kill all workers
+     */
+    killAll(): void;
+    /**
+     * Get pool status
+     */
+    getStatus(): {
+        total: number;
+        busy: number;
+        available: number;
+    };
+}