@stan-chen/simple-cli 0.2.3 → 0.2.4

package/dist/swarm/task.js

@@ -1,221 +0,0 @@
-/**
- * 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

@@ -1,132 +0,0 @@
-/**
- * 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

@@ -1,37 +0,0 @@
-/**
- * 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

@@ -1,109 +0,0 @@
-/**
- * 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;
-    private isTerminating;
-    private onUnexpectedExit;
-    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;
-    };
-}