@stan-chen/simple-cli 0.2.3 → 0.2.5

package/dist/router.js

@@ -1,118 +0,0 @@
-/**
- * MoE Router: Mix of Experts task routing
- * Routes tasks to appropriate model tiers based on complexity
- */
-import { jsonrepair } from 'jsonrepair';
-import { z } from 'zod';
-// Schema for Orchestrator's routing response
-export const RoutingResponseSchema = z.object({
-    complexity: z.number().min(1).max(10),
-    contextRequired: z.enum(['high', 'low']),
-    risk: z.enum(['high', 'low']),
-    recommendedTier: z.number().min(1).max(5),
-    reasoning: z.string()
-});
-// Default tier configurations
-const DEFAULT_TIERS = {
-    1: { role: 'Orchestrator / Architect', defaultModel: 'gpt-5.2-pro' },
-    2: { role: 'Senior Engineer', defaultModel: 'gpt-5.2-codex' },
-    3: { role: 'Junior Engineer', defaultModel: 'gpt-5-mini' },
-    4: { role: 'Intern / Linter', defaultModel: 'gpt-5-nano' },
-    5: { role: 'Safety / Utility', defaultModel: 'gemini-2.5-flash' }
-};
-// Load tier configuration from environment
-export const loadTierConfig = () => {
-    const tiers = new Map();
-    for (const tier of [1, 2, 3, 4, 5]) {
-        const envModel = process.env[`MOE_TIER_${tier}_MODEL`];
-        const model = envModel || DEFAULT_TIERS[tier].defaultModel;
-        // Vercel AI SDK supports provider prefixes (e.g., "anthropic:claude-3", "google:gemini-pro")
-        // Some tests/tools use slash separators ("anthropic/claude-3-opus"). Accept either.
-        const provider = model.includes(':') || model.includes('/') ? model.split(/[:\/]/)[0] : 'openai';
-        tiers.set(tier, {
-            tier,
-            role: DEFAULT_TIERS[tier].role,
-            model,
-            provider
-        });
-    }
-    return tiers;
-};
-// Routing prompt template
-const ROUTING_PROMPT = `You are a task router for an AI coding assistant. Analyze the following task and determine its complexity.
-
-Respond ONLY with valid JSON in this exact format:
-{
-  "complexity": <1-10>,
-  "contextRequired": "<high|low>",
-  "risk": "<high|low>",
-  "recommendedTier": <1-5>,
-  "reasoning": "<brief explanation>"
-}
-
-Tier Guidelines:
-- Tier 1: Complex architecture, critical decisions, multi-system refactoring
-- Tier 2: Feature implementation, significant code changes, debugging complex issues
-- Tier 3: Routine tasks, unit tests, boilerplate code, simple features
-- Tier 4: Typo fixes, formatting, simple imports, trivial changes
-- Tier 5: Basic text operations, summaries
-
-Task to analyze:
-`;
-// Determine routing using Tier 1 orchestrator
-export const routeTask = async (task, orchestratorCall) => {
-    try {
-        const response = await orchestratorCall(ROUTING_PROMPT + task);
-        // Extract JSON from response
-        const jsonMatch = response.match(/\{[\s\S]*\}/);
-        if (!jsonMatch) {
-            return getDefaultRouting(task);
-        }
-        try {
-            const repaired = jsonrepair(jsonMatch[0]);
-            const data = JSON.parse(repaired);
-            // Fuzzy mapping for recommendedTier
-            const tierValue = data.recommendedTier || data.tier || data.recommended_tier || 3;
-            const complexityValue = data.complexity || 5;
-            return {
-                tier: (Math.max(1, Math.min(5, Number(tierValue)))),
-                complexity: Number(complexityValue),
-                contextRequired: data.contextRequired === 'high' ? 'high' : 'low',
-                risk: data.risk === 'high' ? 'high' : 'low',
-                reasoning: data.reasoning || 'No reasoning provided'
-            };
-        }
-        catch (e) {
-            return getDefaultRouting(task);
-        }
-    }
-    catch (error) {
-        console.error('Routing error, using default:', error);
-        return getDefaultRouting(task);
-    }
-};
-// Fallback routing based on simple heuristics
-const getDefaultRouting = (task) => {
-    const taskLower = task.toLowerCase();
-    // Simple keyword-based routing
-    if (taskLower.match(/refactor|architect|design|migrate|security|auth/)) {
-        return { tier: 2, complexity: 7, contextRequired: 'high', risk: 'high', reasoning: 'Complex task keywords detected' };
-    }
-    if (taskLower.match(/implement|feature|add|create|build|debug/)) {
-        return { tier: 2, complexity: 6, contextRequired: 'high', risk: 'low', reasoning: 'Implementation task detected' };
-    }
-    if (taskLower.match(/test|boilerplate|template|simple/)) {
-        return { tier: 3, complexity: 4, contextRequired: 'low', risk: 'low', reasoning: 'Routine task detected' };
-    }
-    if (taskLower.match(/typo|fix|format|import|rename/)) {
-        return { tier: 4, complexity: 2, contextRequired: 'low', risk: 'low', reasoning: 'Minor task detected' };
-    }
-    // Default to Tier 3
-    return { tier: 3, complexity: 5, contextRequired: 'low', risk: 'low', reasoning: 'Default routing' };
-};
-// Format routing decision for logging
-export const formatRoutingDecision = (decision, tiers) => {
-    const tierConfig = tiers.get(decision.tier);
-    return `[Router] Tier ${decision.tier} (${tierConfig?.role}) | Complexity: ${decision.complexity}/10 | Model: ${tierConfig?.model}
-         Reasoning: ${decision.reasoning}`;
-};

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[];
-}