@stan-chen/simple-cli 0.2.3 → 0.2.4

package/dist/swarm/worker.js

@@ -1,369 +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;
-    isTerminating = false;
-    onUnexpectedExit = (code) => {
-        if (!this.isTerminating) {
-            this.emit('error', new Error(`Worker process exited unexpectedly with code ${code}`));
-        }
-    };
-    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) {
-                    (async () => {
-                        try {
-                            await this.kill();
-                        }
-                        catch (e) { /* best-effort */ }
-                        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() {
-        // Keep backwards-compatible signature: return a Promise but allow callers to ignore it.
-        const graceMs = 5000;
-        const promise = (async () => {
-            if (!this.process)
-                return;
-            if (this.process.killed)
-                return;
-            this.isTerminating = true;
-            // stop reporting unexpected-exit while we intentionally terminate
-            try {
-                this.process.off('exit', this.onUnexpectedExit);
-            }
-            catch (e) { }
-            // If IPC is available, politely ask the child to shutdown
-            try {
-                if (this.process.connected) {
-                    try {
-                        this.process.send({ type: 'shutdown' });
-                    }
-                    catch (e) { }
-                }
-            }
-            catch (e) { }
-            try {
-                this.process.kill('SIGTERM');
-            }
-            catch (e) {
-                // ignore
-            }
-            // wait for exit up to graceMs, otherwise force-kill
-            await new Promise((resolve) => {
-                let resolved = false;
-                const onExit = () => {
-                    if (resolved)
-                        return;
-                    resolved = true;
-                    clearTimeout(timer);
-                    resolve(undefined);
-                };
-                const timer = setTimeout(() => {
-                    try {
-                        if (this.process && !this.process.killed)
-                            this.process.kill('SIGKILL');
-                    }
-                    catch (e) { }
-                    // still wait for exit event
-                }, graceMs);
-                try {
-                    if (this.process)
-                        this.process.once('exit', onExit);
-                }
-                catch (e) {
-                    resolve(undefined);
-                }
-            });
-            try {
-                this.process = null;
-            }
-            catch (e) { }
-        })();
-        // Log kill action for auditing
-        try {
-            const fs = require('fs');
-            const path = require('path');
-            fs.appendFileSync(path.join(process.cwd(), '.worker_kill.log'), `${new Date().toISOString()} kill requested for worker ${this.id}\n`);
-        }
-        catch (e) { }
-        return promise;
-    }
-    /**
-     * 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/analyze_file.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 = "analyze_file";
-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/analyze_file.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 = 'analyze_file';
-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/clawBrain.d.ts

@@ -1,23 +0,0 @@
-/**
- * ClawBrain - Agentic Reasoning and Persistence for Autonomous Mode
- */
-import { z } from 'zod';
-import type { Tool } from '../registry.js';
-export declare const inputSchema: z.ZodObject<{
-    action: z.ZodEnum<["set_goal", "update_status", "log_reflection", "get_summary", "prune", "link_files"]>;
-    content: z.ZodOptional<z.ZodString>;
-    status: z.ZodOptional<z.ZodEnum<["planning", "executing", "completed", "failed"]>>;
-    links: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    action: "log_reflection" | "get_summary" | "prune" | "set_goal" | "update_status" | "link_files";
-    status?: "completed" | "failed" | "planning" | "executing" | undefined;
-    content?: string | undefined;
-    links?: string[] | undefined;
-}, {
-    action: "log_reflection" | "get_summary" | "prune" | "set_goal" | "update_status" | "link_files";
-    status?: "completed" | "failed" | "planning" | "executing" | undefined;
-    content?: string | undefined;
-    links?: string[] | undefined;
-}>;
-export declare const execute: (args: Record<string, unknown>, cwd?: string) => Promise<any>;
-export declare const tool: Tool;

package/dist/tools/clawBrain.js

@@ -1,136 +0,0 @@
-/**
- * ClawBrain - Agentic Reasoning and Persistence for Autonomous Mode
- */
-import { z } from 'zod';
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import { join } from 'path';
-export const inputSchema = z.object({
-    action: z.enum(['set_goal', 'update_status', 'log_reflection', 'get_summary', 'prune', 'link_files']),
-    content: z.string().optional().describe('Text content for the action'),
-    status: z.enum(['planning', 'executing', 'completed', 'failed']).optional().describe('Current mission status'),
-    links: z.array(z.string()).optional().describe('Paths or IDs to link in the graph'),
-});
-const MISSION_FILE = '.simple/workdir/mission.json';
-async function loadMission(cwd) {
-    const path = join(cwd, MISSION_FILE);
-    if (!existsSync(path)) {
-        return { goal: 'Unknown', status: 'planning', reflections: [], lastUpdated: Date.now() };
-    }
-    try {
-        return JSON.parse(await readFile(path, 'utf-8'));
-    }
-    catch {
-        return { goal: 'Unknown', status: 'planning', reflections: [], lastUpdated: Date.now() };
-    }
-}
-async function saveMission(cwd, mission) {
-    const path = join(cwd, MISSION_FILE);
-    await mkdir(join(cwd, '.simple/workdir'), { recursive: true });
-    mission.lastUpdated = Date.now();
-    await writeFile(path, JSON.stringify(mission, null, 2));
-}
-export const execute = async (args, cwd = process.cwd()) => {
-    const { action, content, status, links } = inputSchema.parse(args);
-    const mission = await loadMission(cwd);
-    switch (action) {
-        case 'set_goal':
-            mission.goal = content || mission.goal;
-            if (status)
-                mission.status = status;
-            await saveMission(cwd, mission);
-            return { success: true, message: `Goal set to: ${mission.goal}` };
-        case 'update_status':
-            if (status)
-                mission.status = status;
-            if (content)
-                mission.reflections.push(`[Status Update] ${content}`);
-            await saveMission(cwd, mission);
-            return { success: true, status: mission.status };
-        case 'log_reflection':
-            if (content) {
-                mission.reflections.push(content);
-                if (mission.reflections.length > 50)
-                    mission.reflections.shift();
-                await saveMission(cwd, mission);
-                // Write to reflections directory for JIT context
-                const reflectionsDir = join(cwd, '.simple/workdir/memory/reflections');
-                await mkdir(reflectionsDir, { recursive: true });
-                const fileName = `reflection-${Date.now()}.md`;
-                await writeFile(join(reflectionsDir, fileName), content);
-            }
-            return { success: true, added: !!content };
-        case 'link_files':
-            if (links && links.length > 0) {
-                const graphDir = join(cwd, '.simple/workdir/memory/graph');
-                await mkdir(graphDir, { recursive: true });
-                const graphFile = join(graphDir, 'links.jsonl');
-                const entry = JSON.stringify({ timestamp: Date.now(), links, goal: mission.goal }) + '\n';
-                await writeFile(graphFile, entry, { flag: 'a' });
-            }
-            return { success: true, linked: links?.length || 0 };
-        case 'get_summary':
-            return {
-                goal: mission.goal,
-                status: mission.status,
-                recent_reflections: mission.reflections.slice(-5),
-                last_updated: new Date(mission.lastUpdated).toISOString()
-            };
-        case 'prune': {
-            const memoryDir = join(cwd, '.simple/workdir/memory');
-            const notesDir = join(memoryDir, 'notes');
-            await mkdir(notesDir, { recursive: true });
-            if (mission.reflections.length === 0) {
-                return { success: true, message: 'Nothing to prune.' };
-            }
-            const archiveFile = join(notesDir, `archive-${Date.now()}.md`);
-            let consolidated;
-            try {
-                const { createProvider } = await import('../providers/index.js');
-                const provider = createProvider();
-                const prompt = `Consolidate and summarize the following mission reflections into a concise technical brief. 
-                Keep ONLY unique technical insights, discovered paths, and finalized facts. 
-                Original Goal: ${mission.goal}\n\nReflections:\n${mission.reflections.join('\n')}`;
-                console.log('🤖 Summarizing reflections for pruning...');
-                const summary = await provider.generateResponse('You are a technical documentarian.', [
-                    { role: 'user', content: prompt }
-                ]);
-                let summaryText = summary;
-                try {
-                    const parsed = JSON.parse(summary);
-                    summaryText = parsed.thought || parsed.message || summary;
-                }
-                catch { /* not JSON */ }
-                consolidated = [
-                    `# Mission Summary Archive: ${mission.goal}`,
-                    `Status: ${mission.status}`,
-                    `Date: ${new Date().toISOString()}`,
-                    '',
-                    '## Executive Summary',
-                    summaryText
-                ].join('\n');
-            }
-            catch (e) {
-                // Fallback to basic concatenation if LLM fails
-                consolidated = mission.reflections.map(r => `- ${r}`).join('\n');
-            }
-            await writeFile(archiveFile, consolidated);
-            mission.reflections = mission.reflections.slice(-3); // Keep only very recent context
-            await saveMission(cwd, mission);
-            return {
-                success: true,
-                message: 'Memory pruned and summarized with LLM.',
-                archivePath: archiveFile
-            };
-        }
-        default:
-            throw new Error(`Invalid action: ${action}`);
-    }
-};
-export const tool = {
-    name: 'clawBrain',
-    description: 'Manage autonomous mission state and technical reasoning. Use to set goals, log reflections, and track status.',
-    inputSchema,
-    permission: 'write',
-    execute: async (args) => execute(args),
-};

package/dist/tools/claw_brain.d.ts

@@ -1,23 +0,0 @@
-/**
- * ClawBrain - Agentic Reasoning and Persistence for Autonomous Mode
- */
-import { z } from 'zod';
-import type { Tool } from '../registry.js';
-export declare const inputSchema: z.ZodObject<{
-    action: z.ZodEnum<["set_goal", "update_status", "log_reflection", "get_summary", "prune", "link_files"]>;
-    content: z.ZodOptional<z.ZodString>;
-    status: z.ZodOptional<z.ZodEnum<["planning", "executing", "completed", "failed"]>>;
-    links: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    action: "log_reflection" | "get_summary" | "prune" | "set_goal" | "update_status" | "link_files";
-    status?: "completed" | "failed" | "planning" | "executing" | undefined;
-    content?: string | undefined;
-    links?: string[] | undefined;
-}, {
-    action: "log_reflection" | "get_summary" | "prune" | "set_goal" | "update_status" | "link_files";
-    status?: "completed" | "failed" | "planning" | "executing" | undefined;
-    content?: string | undefined;
-    links?: string[] | undefined;
-}>;
-export declare const execute: (args: Record<string, unknown>, cwd?: string) => Promise<any>;
-export declare const tool: Tool;