@stan-chen/simple-cli 0.2.2 → 0.2.3

package/dist/registry.js

@@ -8,6 +8,7 @@ import { join, dirname, basename, extname } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { z } from 'zod';
 import { getMCPManager } from './mcp/manager.js';
+import YAML from 'yaml';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const TOOLS_DIR = join(__dirname, 'tools');
 /**
@@ -41,16 +42,34 @@ function extractDocFromComments(content) {
 }
 /**
  * Parses a tool definition from a Markdown file (.md) or string
+ * Supports YAML frontmatter as per OpenClaw PRD.
  */
-function parseMarkdownTool(content, filename) {
-    const lines = content.split('\n');
-    const meta = {
+export function getMeta(content, filename) {
+    let meta = {
         name: basename(filename, extname(filename)),
         description: '',
         command: '',
         parameters: {},
         permission: 'execute'
     };
+    // 1. Try YAML frontmatter (OpenClaw style)
+    if (content.startsWith('---')) {
+        const end = content.indexOf('---', 3);
+        if (end > -1) {
+            try {
+                const yamlStr = content.slice(3, end);
+                const yamlMeta = YAML.parse(yamlStr);
+                if (yamlMeta) {
+                    return { ...meta, ...yamlMeta };
+                }
+            }
+            catch {
+                // Fall back to manual parsing if YAML fails
+            }
+        }
+    }
+    // 2. Fallback to manual Markdown section parsing
+    const lines = content.split('\n');
     let currentSection = '';
     for (const line of lines) {
         if (line.startsWith('# ')) {
@@ -77,11 +96,32 @@ function parseMarkdownTool(content, filename) {
 }
 // Helper to create a Tool from metadata (JSON or MD)
 function createScriptTool(meta, source, spec) {
+    let inputSchema = z.object({}).passthrough();
+    if (meta.parameters && typeof meta.parameters === 'object') {
+        const shape = {};
+        for (const [key, param] of Object.entries(meta.parameters)) {
+            const p = param;
+            let schema = z.string();
+            if (p.type === 'number' || p === 'number')
+                schema = z.number();
+            else if (p.type === 'boolean' || p === 'boolean')
+                schema = z.boolean();
+            else if (p.type === 'array' || p === 'array')
+                schema = z.array(z.any());
+            else if (p.type === 'object' || p === 'object')
+                schema = z.object({}).passthrough();
+            if (typeof p === 'object' && p.description) {
+                schema = schema.describe(p.description);
+            }
+            shape[key] = schema;
+        }
+        inputSchema = z.object(shape).passthrough();
+    }
     return {
         name: meta.name,
         description: meta.description || `Script tool: ${meta.command}`,
         permission: meta.permission || 'execute',
-        inputSchema: z.object({}).passthrough(), // Flexible schema for scripts
+        inputSchema,
         source,
         specification: spec,
         execute: async (args) => {
@@ -91,10 +131,15 @@ function createScriptTool(meta, source, spec) {
                 if (isWindows && finalCommand.endsWith('.ps1')) {
                     finalCommand = `powershell -ExecutionPolicy Bypass -File ${finalCommand}`;
                 }
+                const env = { ...process.env, TOOL_INPUT: JSON.stringify(args) };
+                // Pass arguments as INPUT_{NAME} for OpenClaw parity
+                for (const [key, value] of Object.entries(args)) {
+                    env[`INPUT_${key.toUpperCase()}`] = typeof value === 'string' ? value : JSON.stringify(value);
+                }
                 const child = spawn(finalCommand, {
                     shell: true,
                     cwd: process.cwd(),
-                    env: { ...process.env, TOOL_INPUT: JSON.stringify(args) },
+                    env,
                 });
                 let stdout = '';
                 let stderr = '';
@@ -143,7 +188,7 @@ async function loadToolsFromDir(dir, source) {
                 if (!tools.has(item)) {
                     const doc = await findDocInDir(fullPath, item);
                     if (doc && doc.file.endsWith('.md')) {
-                        const meta = parseMarkdownTool(doc.content, doc.file);
+                        const meta = getMeta(doc.content, doc.file);
                         if (meta && meta.command) {
                             tools.set(meta.name, createScriptTool(meta, source, doc.content));
                         }
@@ -158,19 +203,27 @@ async function loadToolsFromDir(dir, source) {
                 if (item.includes('.test.'))
                     continue;
                 try {
-                    const module = await import(pathToFileURL(fullPath).href);
-                    const toolDef = module.tool || module;
-                    if (toolDef.name && toolDef.execute) {
-                        const schema = toolDef.inputSchema || toolDef.schema;
-                        tools.set(toolDef.name, {
-                            name: toolDef.name,
-                            description: toolDef.description || 'No description',
-                            permission: toolDef.permission || 'read',
-                            inputSchema: schema || z.object({}),
-                            execute: toolDef.execute,
-                            source,
-                        });
-                        continue;
+                    // Peek at file content to see if it looks like a module with exports
+                    // This avoids executing scripts with top-level side effects during import
+                    const content = await readFile(fullPath, 'utf-8');
+                    if (!content.includes('export ')) {
+                        // Fall through to Case 2 (Generic Script)
+                    }
+                    else {
+                        const module = await import(pathToFileURL(fullPath).href);
+                        const toolDef = module.tool || module;
+                        if (toolDef.name && toolDef.execute) {
+                            const schema = toolDef.inputSchema || toolDef.schema;
+                            tools.set(toolDef.name, {
+                                name: toolDef.name,
+                                description: toolDef.description || 'No description',
+                                permission: toolDef.permission || 'read',
+                                inputSchema: schema || z.object({}),
+                                execute: toolDef.execute,
+                                source,
+                            });
+                            continue;
+                        }
                     }
                 }
                 catch { /* might be a script, fall through */ }
@@ -189,12 +242,12 @@ async function loadToolsFromDir(dir, source) {
                             meta = JSON.parse(companion.content);
                         }
                         else {
-                            meta = parseMarkdownTool(companion.content, companion.file);
+                            meta = getMeta(companion.content, companion.file);
                             specContent = companion.content;
                         }
                     }
                     else if (internalDoc) {
-                        meta = parseMarkdownTool(internalDoc, item);
+                        meta = getMeta(internalDoc, item);
                         if (!meta.command) {
                             if (ext === '.py')
                                 meta.command = `python ${fullPath}`;
@@ -223,7 +276,7 @@ async function loadToolsFromDir(dir, source) {
                         meta = JSON.parse(content);
                     }
                     else {
-                        meta = parseMarkdownTool(content, item);
+                        meta = getMeta(content, item);
                     }
                     if (meta && meta.name && meta.command) {
                         tools.set(meta.name, createScriptTool(meta, source, content));
@@ -243,6 +296,7 @@ export const loadTools = async () => {
     const customDirs = ['skills', 'scripts', 'tools', '.simple-cli/tools'];
     const builtinTools = await loadToolsFromDir(TOOLS_DIR, 'builtin');
     const allProjectTools = new Map();
+    // Local project dirs
     for (const d of customDirs) {
         const dirPath = join(process.cwd(), d);
         const tools = await loadToolsFromDir(dirPath, 'project');
@@ -250,6 +304,15 @@ export const loadTools = async () => {
             allProjectTools.set(name, tool);
         }
     }
+    // Global OpenClaw skills (from PRD)
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const globalClawDir = join(home, '.openclaw', 'workspace', 'skills');
+    const globalTools = await loadToolsFromDir(globalClawDir, 'project');
+    for (const [name, tool] of globalTools) {
+        if (!allProjectTools.has(name)) {
+            allProjectTools.set(name, tool);
+        }
+    }
     return new Map([...builtinTools, ...allProjectTools]);
 };
 // Load MCP tools and merge with built-in tools
@@ -282,6 +345,7 @@ export const getToolDefinitions = (tools) => {
     const builtinTools = [];
     const projectTools = [];
     const mcpTools = [];
+    const isClaw = process.argv.includes('--claw') || process.argv.includes('-claw');
     for (const tool of tools.values()) {
         if (tool.source === 'mcp') {
             mcpTools.push(tool);

package/dist/router.js

@@ -2,6 +2,7 @@
  * 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({
@@ -25,9 +26,9 @@ export const loadTierConfig = () => {
     for (const tier of [1, 2, 3, 4, 5]) {
         const envModel = process.env[`MOE_TIER_${tier}_MODEL`];
         const model = envModel || DEFAULT_TIERS[tier].defaultModel;
-        // LiteLLM auto-detects provider from model name prefix (e.g., "anthropic/claude-3", "gemini/gemini-pro")
-        // For OpenAI models without prefix, it defaults to OpenAI
-        const provider = model.includes('/') ? model.split('/')[0] : 'openai';
+        // 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,
@@ -67,14 +68,23 @@ export const routeTask = async (task, orchestratorCall) => {
         if (!jsonMatch) {
             return getDefaultRouting(task);
         }
-        const parsed = RoutingResponseSchema.parse(JSON.parse(jsonMatch[0]));
-        return {
-            tier: parsed.recommendedTier,
-            complexity: parsed.complexity,
-            contextRequired: parsed.contextRequired,
-            risk: parsed.risk,
-            reasoning: parsed.reasoning
-        };
+        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);

package/dist/skills.js

@@ -45,7 +45,7 @@ When making changes to files:
 2. Make precise, targeted changes using search/replace
 3. Verify changes don't break existing functionality
 4. Follow the existing code style`,
-        tools: ['readFiles', 'writeFiles', 'runCommand', 'glob', 'grep', 'lint', 'reloadTools'],
+        tools: ['read_files', 'write_files', 'run_command', 'glob', 'grep', 'lint', 'reload_tools', 'scheduler'],
     },
     // Architect skill for planning
     architect: {
@@ -66,7 +66,7 @@ When working on architecture:
 
 Focus on high-level design rather than implementation details.
 Generate diagrams and documentation when helpful.`,
-        tools: ['readFiles', 'glob', 'grep', 'memory'],
+        tools: ['read_files', 'glob', 'grep', 'memory'],
         modelPreference: 'orchestrator',
     },
     // Ask skill for questions only
@@ -87,7 +87,7 @@ You should NOT:
 - Create new files
 
 Always read files before answering questions about them.`,
-        tools: ['readFiles', 'glob', 'grep'],
+        tools: ['read_files', 'glob', 'grep'],
     },
     // Help/docs skill
     help: {
@@ -102,7 +102,7 @@ Always read files before answering questions about them.`,
 
 Be concise and provide examples when helpful.
 Reference official documentation when available.`,
-        tools: ['readFiles', 'scrapeUrl'],
+        tools: ['read_files', 'scrape_url'],
     },
     // Test skill
     test: {
@@ -122,7 +122,7 @@ Test guidelines:
 - Use appropriate mocking when needed
 
 After writing tests, run them to verify they pass.`,
-        tools: ['readFiles', 'writeFiles', 'runCommand', 'glob', 'grep', 'lint'],
+        tools: ['read_files', 'write_files', 'run_command', 'glob', 'grep', 'lint', 'scheduler'],
     },
     // Debug skill
     debug: {
@@ -141,7 +141,7 @@ Debugging tips:
 - Check recent changes that might have caused the issue
 - Look for common patterns (null checks, async issues, etc.)
 - Use the linter to catch syntax errors`,
-        tools: ['readFiles', 'writeFiles', 'runCommand', 'grep', 'lint', 'git'],
+        tools: ['read_files', 'write_files', 'run_command', 'grep', 'lint', 'git', 'scheduler'],
     },
     // Refactor skill
     refactor: {
@@ -162,7 +162,7 @@ Refactoring principles:
 - Follow SOLID principles
 
 Always run tests after refactoring to ensure nothing broke.`,
-        tools: ['readFiles', 'writeFiles', 'runCommand', 'glob', 'grep', 'lint', 'git'],
+        tools: ['read_files', 'write_files', 'run_command', 'glob', 'grep', 'lint', 'git', 'scheduler'],
     },
     // Review skill
     review: {
@@ -178,7 +178,7 @@ Always run tests after refactoring to ensure nothing broke.`,
 
 Provide constructive feedback with specific suggestions.
 Prioritize critical issues over minor style concerns.`,
-        tools: ['readFiles', 'glob', 'grep', 'git', 'lint'],
+        tools: ['read_files', 'glob', 'grep', 'git', 'lint'],
     },
     // Shell skill
     shell: {
@@ -196,7 +196,7 @@ Safety guidelines:
 - Use safe defaults (no force flags unless needed)
 - Be careful with destructive operations
 - Test commands before applying to production`,
-        tools: ['runCommand', 'readFiles', 'writeFiles', 'glob'],
+        tools: ['run_command', 'read_files', 'write_files', 'glob'],
     },
     // Git skill
     git: {
@@ -215,7 +215,7 @@ Git guidelines:
 - Make small, focused commits
 - Keep branches up to date
 - Review changes before committing`,
-        tools: ['git', 'readFiles', 'glob', 'grep'],
+        tools: ['git', 'read_files', 'glob', 'grep'],
     },
 };
 // Get active skill from environment or default

package/dist/swarm/worker.d.ts

@@ -17,6 +17,8 @@ export declare class Worker extends EventEmitter {
     private startedAt;
     private output;
     private options;
+    private isTerminating;
+    private onUnexpectedExit;
     constructor(options: WorkerOptions);
     /**
      * Get current worker status

package/dist/swarm/worker.js

@@ -12,6 +12,12 @@ export class Worker extends EventEmitter {
     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)}`;
@@ -114,14 +120,19 @@ export class Worker extends EventEmitter {
             // Set timeout
             timeoutId = setTimeout(() => {
                 if (!resolved) {
-                    this.kill();
-                    finish({
-                        success: false,
-                        filesChanged: [],
-                        error: `Task timed out after ${timeout}ms`,
-                        duration: timeout,
-                        output: this.output,
-                    });
+                    (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
@@ -177,15 +188,74 @@ export class Worker extends EventEmitter {
      * 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');
+        // 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);
                 }
-            }, 5000);
+            });
+            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

package/dist/tools/analyze_file.d.ts

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

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

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