@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/swarm/worker.js

@@ -1,299 +0,0 @@
-/**
- * Worker - Spawns and manages Simple-CLI worker processes
- */
-import { spawn } from 'child_process';
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-export class Worker extends EventEmitter {
-    id;
-    process = null;
-    state = 'idle';
-    currentTask = null;
-    startedAt = 0;
-    output = '';
-    options;
-    constructor(options) {
-        super();
-        this.id = `worker-${randomUUID().slice(0, 8)}`;
-        this.options = options;
-    }
-    /**
-     * Get current worker status
-     */
-    getStatus() {
-        return {
-            id: this.id,
-            pid: this.process?.pid,
-            state: this.state,
-            currentTask: this.currentTask?.id,
-            startedAt: this.startedAt || undefined,
-            completedAt: this.state === 'completed' || this.state === 'failed' ? Date.now() : undefined,
-        };
-    }
-    /**
-     * Execute a task
-     */
-    async execute(task) {
-        if (this.state === 'running') {
-            throw new Error(`Worker ${this.id} is already running a task`);
-        }
-        this.currentTask = task;
-        this.state = 'running';
-        this.startedAt = Date.now();
-        this.output = '';
-        return new Promise((resolve, reject) => {
-            const timeout = task.timeout || this.options.timeout;
-            let timeoutId = null;
-            let resolved = false;
-            const cleanup = () => {
-                if (timeoutId)
-                    clearTimeout(timeoutId);
-                this.process = null;
-            };
-            const finish = (result) => {
-                if (resolved)
-                    return;
-                resolved = true;
-                cleanup();
-                this.state = result.success ? 'completed' : 'failed';
-                this.emit('complete', result);
-                resolve(result);
-            };
-            // Build the prompt from task
-            const prompt = this.buildPrompt(task);
-            // Spawn Simple-CLI process
-            const args = ['--yolo'];
-            if (this.options.yolo)
-                args.push('--yolo');
-            args.push(prompt);
-            // Use node to run the CLI directly
-            const cliPath = new URL('../index.js', import.meta.url).pathname;
-            this.process = spawn('node', [cliPath, ...args], {
-                cwd: this.options.cwd,
-                env: {
-                    ...process.env,
-                    ...this.options.env,
-                    SIMPLE_CLI_WORKER: this.id,
-                    SIMPLE_CLI_TASK: task.id,
-                },
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            this.emit('spawn', this.getStatus());
-            // Collect output
-            this.process.stdout?.on('data', (data) => {
-                this.output += data.toString();
-            });
-            this.process.stderr?.on('data', (data) => {
-                this.output += data.toString();
-            });
-            // Handle process exit
-            this.process.on('close', (code) => {
-                const duration = Date.now() - this.startedAt;
-                const success = code === 0;
-                // Parse output for changed files (simplified)
-                const filesChanged = this.parseChangedFiles(this.output);
-                const commitHash = this.parseCommitHash(this.output);
-                finish({
-                    success,
-                    filesChanged,
-                    commitHash,
-                    error: success ? undefined : `Process exited with code ${code}`,
-                    duration,
-                    output: this.output,
-                });
-            });
-            this.process.on('error', (err) => {
-                finish({
-                    success: false,
-                    filesChanged: [],
-                    error: err.message,
-                    duration: Date.now() - this.startedAt,
-                    output: this.output,
-                });
-            });
-            // Set timeout
-            timeoutId = setTimeout(() => {
-                if (!resolved) {
-                    this.kill();
-                    finish({
-                        success: false,
-                        filesChanged: [],
-                        error: `Task timed out after ${timeout}ms`,
-                        duration: timeout,
-                        output: this.output,
-                    });
-                }
-            }, timeout);
-            // Send task to stdin and close
-            this.process.stdin?.write(prompt);
-            this.process.stdin?.end();
-        });
-    }
-    /**
-     * Build prompt from task
-     */
-    buildPrompt(task) {
-        let prompt = task.description;
-        if (task.scope.files && task.scope.files.length > 0) {
-            prompt += `\n\nFocus on these files: ${task.scope.files.join(', ')}`;
-        }
-        if (task.scope.directories && task.scope.directories.length > 0) {
-            prompt += `\n\nWork in these directories: ${task.scope.directories.join(', ')}`;
-        }
-        if (task.scope.pattern) {
-            prompt += `\n\nApply to files matching: ${task.scope.pattern}`;
-        }
-        return prompt;
-    }
-    /**
-     * Parse changed files from output
-     */
-    parseChangedFiles(output) {
-        const files = [];
-        // Look for common patterns indicating file changes
-        const patterns = [
-            /(?:wrote|created|modified|updated)\s+([^\s]+)/gi,
-            /\[Result\].*(?:wrote|created)\s+([^\s]+)/gi,
-        ];
-        for (const pattern of patterns) {
-            let match;
-            while ((match = pattern.exec(output)) !== null) {
-                const file = match[1].replace(/['"`,]/g, '');
-                if (file && !files.includes(file)) {
-                    files.push(file);
-                }
-            }
-        }
-        return files;
-    }
-    /**
-     * Parse commit hash from output
-     */
-    parseCommitHash(output) {
-        const match = output.match(/commit\s+([a-f0-9]{7,40})/i);
-        return match ? match[1] : undefined;
-    }
-    /**
-     * Kill the worker process
-     */
-    kill() {
-        if (this.process && !this.process.killed) {
-            this.process.kill('SIGTERM');
-            // Force kill after 5 seconds
-            setTimeout(() => {
-                if (this.process && !this.process.killed) {
-                    this.process.kill('SIGKILL');
-                }
-            }, 5000);
-        }
-    }
-    /**
-     * Check if worker is busy
-     */
-    isBusy() {
-        return this.state === 'running';
-    }
-    /**
-     * Check if worker is available
-     */
-    isAvailable() {
-        return this.state === 'idle' || this.state === 'completed' || this.state === 'failed';
-    }
-    /**
-     * Reset worker for reuse
-     */
-    reset() {
-        this.state = 'idle';
-        this.currentTask = null;
-        this.startedAt = 0;
-        this.output = '';
-        this.process = null;
-    }
-    /**
-     * Get task output
-     */
-    getOutput() {
-        return this.output;
-    }
-}
-/**
- * Worker pool for managing multiple workers
- */
-export class WorkerPool {
-    workers = [];
-    inUse = new Set();
-    options;
-    maxWorkers;
-    constructor(maxWorkers, options) {
-        this.maxWorkers = maxWorkers;
-        this.options = options;
-    }
-    /**
-     * Get an available worker (or create one if pool not full)
-     */
-    getWorker() {
-        // Create new worker if pool not full
-        if (this.workers.length < this.maxWorkers) {
-            const worker = new Worker(this.options);
-            this.workers.push(worker);
-            this.inUse.add(worker.id);
-            return worker;
-        }
-        // Try to find an available worker that's not in use
-        const available = this.workers.find(w => w.isAvailable() && !this.inUse.has(w.id));
-        if (available) {
-            available.reset();
-            this.inUse.add(available.id);
-            return available;
-        }
-        return null;
-    }
-    /**
-     * Release a worker back to the pool
-     */
-    releaseWorker(worker) {
-        this.inUse.delete(worker.id);
-    }
-    /**
-     * Get all workers
-     */
-    getAllWorkers() {
-        return [...this.workers];
-    }
-    /**
-     * Get worker by ID
-     */
-    getWorkerById(id) {
-        return this.workers.find(w => w.id === id);
-    }
-    /**
-     * Get number of busy workers
-     */
-    getBusyCount() {
-        return this.workers.filter(w => w.isBusy()).length;
-    }
-    /**
-     * Get number of available workers
-     */
-    getAvailableCount() {
-        return Math.max(0, this.maxWorkers - this.getBusyCount());
-    }
-    /**
-     * Kill all workers
-     */
-    killAll() {
-        for (const worker of this.workers) {
-            worker.kill();
-        }
-    }
-    /**
-     * Get pool status
-     */
-    getStatus() {
-        return {
-            total: this.workers.length,
-            busy: this.getBusyCount(),
-            available: this.getAvailableCount(),
-        };
-    }
-}

package/dist/tools/analyzeFile.d.ts

@@ -1,16 +0,0 @@
-/**
- * Tool: analyzeFile
- * Structured analysis of a Source File (TS/JS) using ts-morph
- */
-import { z } from 'zod';
-export declare const name = "analyzeFile";
-export declare const description = "Perform structured analysis of a TypeScript/JavaScript file to extract classes, functions, and interfaces.";
-export declare const permission: "read";
-export declare const schema: z.ZodObject<{
-    path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
-export declare const execute: (args: Record<string, unknown>) => Promise<unknown>;

package/dist/tools/analyzeFile.js

@@ -1,43 +0,0 @@
-/**
- * Tool: analyzeFile
- * Structured analysis of a Source File (TS/JS) using ts-morph
- */
-import { Project, ScriptTarget } from 'ts-morph';
-import { z } from 'zod';
-import { readFile } from 'fs/promises';
-export const name = 'analyzeFile';
-export const description = 'Perform structured analysis of a TypeScript/JavaScript file to extract classes, functions, and interfaces.';
-export const permission = 'read';
-export const schema = z.object({
-    path: z.string().describe('Path to the file to analyze')
-});
-export const execute = async (args) => {
-    const parsed = schema.parse(args);
-    const path = parsed.path;
-    try {
-        const content = await readFile(path, 'utf-8');
-        const project = new Project({
-            compilerOptions: { target: ScriptTarget.ESNext, allowJs: true },
-            useInMemoryFileSystem: true
-        });
-        const sourceFile = project.createSourceFile(path, content);
-        return {
-            path,
-            classes: sourceFile.getClasses().map(c => ({
-                name: c.getName(),
-                methods: c.getMethods().map(m => m.getName()),
-                properties: c.getProperties().map(p => p.getName())
-            })),
-            functions: sourceFile.getFunctions().map(f => ({
-                name: f.getName(),
-                params: f.getParameters().map(p => p.getName())
-            })),
-            interfaces: sourceFile.getInterfaces().map(i => i.getName()),
-            types: sourceFile.getTypeAliases().map(t => t.getName()),
-            exports: sourceFile.getExportedDeclarations().keys()
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to analyze file ${path}: ${error instanceof Error ? error.message : error}`);
-    }
-};

package/dist/tools/git.d.ts

@@ -1,40 +0,0 @@
-/**
- * Git Tool - Git operations for version control
- * Based on Aider's repo.py
- */
-import { z } from 'zod';
-import type { Tool } from '../registry.js';
-export declare const inputSchema: z.ZodObject<{
-    operation: z.ZodEnum<["status", "diff", "log", "add", "commit", "branch", "checkout", "stash", "show", "blame"]>;
-    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    cwd: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    operation: "status" | "diff" | "log" | "add" | "commit" | "branch" | "checkout" | "stash" | "show" | "blame";
-    files?: string[] | undefined;
-    message?: string | undefined;
-    args?: string[] | undefined;
-    cwd?: string | undefined;
-}, {
-    operation: "status" | "diff" | "log" | "add" | "commit" | "branch" | "checkout" | "stash" | "show" | "blame";
-    files?: string[] | undefined;
-    message?: string | undefined;
-    args?: string[] | undefined;
-    cwd?: string | undefined;
-}>;
-type GitInput = z.infer<typeof inputSchema>;
-interface GitResult {
-    operation: string;
-    success: boolean;
-    output: string;
-    error?: string;
-}
-export declare function execute(input: GitInput): Promise<GitResult>;
-export declare function getCurrentBranch(cwd?: string): string | null;
-export declare function getChangedFiles(cwd?: string): string[];
-export declare function getTrackedFiles(cwd?: string): string[];
-export declare function isIgnored(filePath: string, cwd?: string): boolean;
-export declare function getStagedDiff(cwd?: string): string | null;
-export declare const tool: Tool;
-export {};

package/dist/tools/git.js

@@ -1,236 +0,0 @@
-/**
- * Git Tool - Git operations for version control
- * Based on Aider's repo.py
- */
-import { z } from 'zod';
-import { execSync, spawnSync } from 'child_process';
-// Input schema for git operations
-export const inputSchema = z.object({
-    operation: z.enum([
-        'status',
-        'diff',
-        'log',
-        'add',
-        'commit',
-        'branch',
-        'checkout',
-        'stash',
-        'show',
-        'blame',
-    ]).describe('Git operation to perform'),
-    args: z.array(z.string()).optional().describe('Additional arguments for the operation'),
-    cwd: z.string().optional().describe('Working directory'),
-    message: z.string().optional().describe('Commit message (for commit operation)'),
-    files: z.array(z.string()).optional().describe('Files to operate on'),
-});
-// Check if directory is a git repository
-function isGitRepo(cwd) {
-    try {
-        execSync('git rev-parse --git-dir', {
-            cwd,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Run git command
-function runGit(args, cwd) {
-    const operation = args[0] || 'unknown';
-    try {
-        const result = spawnSync('git', args, {
-            cwd,
-            encoding: 'utf-8',
-            maxBuffer: 10 * 1024 * 1024, // 10MB
-            timeout: 60000,
-        });
-        if (result.error) {
-            return {
-                operation,
-                success: false,
-                output: '',
-                error: result.error.message,
-            };
-        }
-        const output = (result.stdout || '') + (result.stderr || '');
-        const success = result.status === 0;
-        return {
-            operation,
-            success,
-            output: output.trim(),
-            error: success ? undefined : output.trim(),
-        };
-    }
-    catch (error) {
-        return {
-            operation,
-            success: false,
-            output: '',
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-// Execute git operation
-export async function execute(input) {
-    const { operation, args = [], cwd = process.cwd(), message, files = [], } = inputSchema.parse(input);
-    // Check if it's a git repository
-    if (!isGitRepo(cwd)) {
-        return {
-            operation,
-            success: false,
-            output: '',
-            error: 'Not a git repository',
-        };
-    }
-    // Build git command based on operation
-    let gitArgs = [];
-    switch (operation) {
-        case 'status':
-            gitArgs = ['status', '--porcelain=v1', ...args];
-            break;
-        case 'diff':
-            gitArgs = ['diff', '--no-color', ...args, ...files];
-            break;
-        case 'log':
-            gitArgs = [
-                'log',
-                '--oneline',
-                '--no-decorate',
-                '-n', '20',
-                ...args,
-            ];
-            break;
-        case 'add':
-            if (files.length === 0) {
-                return {
-                    operation,
-                    success: false,
-                    output: '',
-                    error: 'No files specified to add',
-                };
-            }
-            gitArgs = ['add', ...args, ...files];
-            break;
-        case 'commit':
-            if (!message) {
-                return {
-                    operation,
-                    success: false,
-                    output: '',
-                    error: 'Commit message required',
-                };
-            }
-            gitArgs = ['commit', '-m', message, ...args];
-            break;
-        case 'branch':
-            gitArgs = ['branch', '--no-color', ...args];
-            break;
-        case 'checkout':
-            gitArgs = ['checkout', ...args, ...files];
-            break;
-        case 'stash':
-            gitArgs = ['stash', ...args];
-            break;
-        case 'show':
-            gitArgs = ['show', '--no-color', '--stat', ...args];
-            break;
-        case 'blame':
-            if (files.length === 0) {
-                return {
-                    operation,
-                    success: false,
-                    output: '',
-                    error: 'File path required for blame',
-                };
-            }
-            gitArgs = ['blame', '--no-color', '-l', ...args, files[0]];
-            break;
-        default:
-            return {
-                operation,
-                success: false,
-                output: '',
-                error: `Unknown operation: ${operation}`,
-            };
-    }
-    return runGit(gitArgs, cwd);
-}
-// Get current branch
-export function getCurrentBranch(cwd = process.cwd()) {
-    try {
-        const result = execSync('git rev-parse --abbrev-ref HEAD', {
-            cwd,
-            encoding: 'utf-8',
-        });
-        return result.trim();
-    }
-    catch {
-        return null;
-    }
-}
-// Get list of changed files
-export function getChangedFiles(cwd = process.cwd()) {
-    try {
-        const result = execSync('git status --porcelain=v1', {
-            cwd,
-            encoding: 'utf-8',
-        });
-        return result
-            .split('\n')
-            .filter(Boolean)
-            .map(line => line.slice(3).trim());
-    }
-    catch {
-        return [];
-    }
-}
-// Get list of tracked files
-export function getTrackedFiles(cwd = process.cwd()) {
-    try {
-        const result = execSync('git ls-files', {
-            cwd,
-            encoding: 'utf-8',
-        });
-        return result.split('\n').filter(Boolean);
-    }
-    catch {
-        return [];
-    }
-}
-// Check if file is ignored
-export function isIgnored(filePath, cwd = process.cwd()) {
-    try {
-        execSync(`git check-ignore -q "${filePath}"`, {
-            cwd,
-            encoding: 'utf-8',
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Get commit message for staged changes (using AI)
-export function getStagedDiff(cwd = process.cwd()) {
-    try {
-        const result = execSync('git diff --cached', {
-            cwd,
-            encoding: 'utf-8',
-        });
-        return result.trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-// Tool definition
-export const tool = {
-    name: 'git',
-    description: 'Perform git operations: status, diff, log, add, commit, branch, checkout, stash, show, blame',
-    inputSchema,
-    permission: 'execute',
-    execute: async (args) => execute(args),
-};

package/dist/tools/glob.d.ts

@@ -1,34 +0,0 @@
-/**
- * Glob Tool - Find files matching patterns
- * Uses fast-glob for reliable glob matching (with fallback)
- */
-import { z } from 'zod';
-import type { Tool } from '../registry.js';
-export declare const inputSchema: z.ZodObject<{
-    pattern: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    includeDirectories: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    ignore: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    pattern: string;
-    maxResults: number;
-    includeDirectories: boolean;
-    ignore?: string[] | undefined;
-    cwd?: string | undefined;
-}, {
-    pattern: string;
-    ignore?: string[] | undefined;
-    cwd?: string | undefined;
-    maxResults?: number | undefined;
-    includeDirectories?: boolean | undefined;
-}>;
-type GlobInput = z.infer<typeof inputSchema>;
-export declare function execute(input: GlobInput): Promise<{
-    pattern: string;
-    matches: string[];
-    count: number;
-    truncated: boolean;
-}>;
-export declare const tool: Tool;
-export {};