@stan-chen/simple-cli 0.2.5 → 0.2.7

package/dist/builtins.js

@@ -1,11 +1,49 @@
 import { readFile, writeFile, readdir, unlink, mkdir, stat } from 'fs/promises';
 import { existsSync } from 'fs';
-import { join, resolve, relative, extname } from 'path';
-import { exec } from 'child_process';
+import { join, resolve, relative, extname, isAbsolute } from 'path';
+import { exec, spawn, execSync } from 'child_process';
 import { promisify } from 'util';
 import { z } from 'zod';
 import glob from 'fast-glob';
+import { Scheduler } from './scheduler.js';
+import { AsyncTaskManager } from './async_tasks.js';
+import { loadConfig } from './config.js';
 const execAsync = promisify(exec);
+const activeProcesses = [];
+export const cleanupProcesses = () => {
+    for (const proc of activeProcesses) {
+        if (!proc.killed && proc.pid) {
+            if (process.platform === 'win32') {
+                try {
+                    execSync(`taskkill /F /T /PID ${proc.pid}`);
+                }
+                catch {
+                    proc.kill('SIGTERM');
+                }
+            }
+            else {
+                proc.kill('SIGTERM');
+            }
+        }
+    }
+};
+// Handle cleanup on exit
+process.on('exit', cleanupProcesses);
+process.on('SIGINT', () => {
+    cleanupProcesses();
+    process.exit();
+});
+process.on('SIGTERM', () => {
+    cleanupProcesses();
+    process.exit();
+});
+// Helper function to validate path is within allowed workspace
+const isPathAllowed = (p) => {
+    const resolvedPath = resolve(p);
+    const workspaceRoot = resolve(process.cwd());
+    const relativePath = relative(workspaceRoot, resolvedPath);
+    return !relativePath.startsWith('..') && !isAbsolute(relativePath);
+};
 export const readFiles = {
     name: 'read_files',
     description: 'Read contents of one or more files',
@@ -26,6 +64,10 @@ export const readFiles = {
         const results = [];
         for (const p of paths) {
             try {
+                if (!isPathAllowed(p)) {
+                    results.push({ path: p, error: "Access denied: Path is outside the allowed workspace." });
+                    continue;
+                }
                 if (existsSync(p)) {
                     const content = await readFile(p, 'utf-8');
                     results.push({ path: p, content });
@@ -85,6 +127,10 @@ export const writeFiles = {
                     results.push({ success: false, message: 'File path missing' });
                     continue;
                 }
+                if (!isPathAllowed(f.path)) {
+                    results.push({ path: f.path, success: false, message: "Access denied: Path is outside the allowed workspace." });
+                    continue;
+                }
                 const dir = resolve(f.path, '..');
                 if (!existsSync(dir)) {
                     await mkdir(dir, { recursive: true });
@@ -130,11 +176,29 @@ export const createTool = {
         scope: z.enum(['local', 'global']).default('local')
     }),
     execute: async ({ source_path, name, description, usage, scope }) => {
+        if (!isPathAllowed(source_path))
+            return `Access denied: Path is outside the allowed workspace.`;
         if (!existsSync(source_path))
             return `Source file not found: ${source_path}`;
-        const content = await readFile(source_path, 'utf-8');
         const ext = extname(source_path);
         const filename = `${name}${ext}`;
+        const targetDir = scope === 'global'
+            ? join(process.env.HOME || process.cwd(), '.agent', 'tools')
+            : join(process.cwd(), '.agent', 'tools');
+        // Check for existing tools
+        if (existsSync(join(targetDir, filename))) {
+            return `Error: Tool '${name}' already exists at ${join(targetDir, filename)}. Please use a different name or delete the existing tool.`;
+        }
+        // Check for similar names (simple containment)
+        if (existsSync(targetDir)) {
+            const existing = await readdir(targetDir);
+            const similar = existing.find(f => f.startsWith(name) || name.startsWith(f.split('.')[0]));
+            if (similar) {
+                // Warning only, allow creation but notify
+                console.warn(`Warning: A similar tool '${similar}' already exists.`);
+            }
+        }
+        const content = await readFile(source_path, 'utf-8');
         let header = '';
         if (ext === '.js' || ext === '.ts') {
             header = `/**\n * ${name}\n * ${description}\n * Usage: ${usage}\n */\n\n`;
@@ -142,9 +206,6 @@ export const createTool = {
         else if (ext === '.py') {
             header = `"""\n${name}\n${description}\nUsage: ${usage}\n"""\n\n`;
         }
-        const targetDir = scope === 'global'
-            ? join(process.env.HOME || process.cwd(), '.agent', 'tools')
-            : join(process.cwd(), '.agent', 'tools');
         await mkdir(targetDir, { recursive: true });
         const targetPath = join(targetDir, filename);
         await writeFile(targetPath, header + content);
@@ -210,6 +271,14 @@ export const listFiles = {
         maxResults: z.number().optional()
     }),
     execute: async ({ pattern, path, ignore, includeDirectories, maxResults }) => {
+        if (!isPathAllowed(path)) {
+            return {
+                matches: [],
+                count: 0,
+                truncated: false,
+                error: "Access denied: Path is outside the allowed workspace."
+            };
+        }
         const files = await glob(pattern, {
             cwd: path,
             ignore: ignore,
@@ -239,6 +308,9 @@ export const searchFiles = {
         filesOnly: z.boolean().default(false)
     }),
     execute: async ({ pattern, path, glob: globPattern, ignoreCase, contextLines, maxResults, filesOnly }) => {
+        if (!isPathAllowed(path)) {
+            return { matches: [], count: 0, truncated: false, error: "Access denied: Path is outside the allowed workspace." };
+        }
         let files = [];
         try {
             const stats = await stat(path);
@@ -325,15 +397,35 @@ export const listDir = {
     description: 'List contents of a directory',
     inputSchema: z.object({ path: z.string().default('.') }),
     execute: async ({ path }) => {
+        if (!isPathAllowed(path))
+            return "Access denied: Path is outside the allowed workspace.";
         const items = await readdir(path, { withFileTypes: true });
         return items.map(i => ({ name: i.name, isDir: i.isDirectory() }));
     }
 };
 export const runCommand = {
     name: 'run_command',
-    description: 'Run a shell command',
-    inputSchema: z.object({ command: z.string(), timeout: z.number().optional() }),
-    execute: async ({ command, timeout }) => {
+    description: 'Run a shell command. Use background: true for servers or long-running tasks.',
+    inputSchema: z.object({
+        command: z.string(),
+        timeout: z.number().optional(),
+        background: z.boolean().default(false).describe('Run command in background and return immediately')
+    }),
+    execute: async ({ command, timeout, background }) => {
+        if (background) {
+            const child = spawn(command, {
+                shell: true,
+                detached: true,
+                stdio: 'ignore'
+            });
+            child.unref();
+            activeProcesses.push(child);
+            return {
+                message: `Started background process: ${command}`,
+                pid: child.pid,
+                success: true
+            };
+        }
         try {
             const { stdout, stderr } = await execAsync(command, { timeout });
             return { stdout, stderr, exitCode: 0, timedOut: false };
@@ -350,6 +442,31 @@ export const runCommand = {
         }
     }
 };
+export const stopCommand = {
+    name: 'stop_command',
+    description: 'Stop a background process by its PID',
+    inputSchema: z.object({ pid: z.number() }),
+    execute: async ({ pid }) => {
+        if (process.platform === 'win32') {
+            try {
+                await execAsync(`taskkill /F /T /PID ${pid}`);
+                return `Successfully stopped process ${pid}`;
+            }
+            catch (e) {
+                return `Error stopping process ${pid}: ${e.message}`;
+            }
+        }
+        else {
+            try {
+                process.kill(pid, 'SIGTERM');
+                return `Sent SIGTERM to process ${pid}`;
+            }
+            catch (e) {
+                return `Error stopping process ${pid}: ${e.message}`;
+            }
+        }
+    }
+};
 export const deleteFile = {
     name: 'delete_file',
     description: 'Delete a file',
@@ -358,6 +475,8 @@ export const deleteFile = {
         const path = args.path || args.file || args.filename;
         if (!path)
             return "Error: 'path' argument required";
+        if (!isPathAllowed(path))
+            return "Access denied: Path is outside the allowed workspace.";
         if (existsSync(path)) {
             await unlink(path);
             return `Deleted ${path}`;
@@ -375,6 +494,8 @@ export const gitTool = {
         message: z.string().optional()
     }),
     execute: async ({ operation, cwd, files, message }) => {
+        if (!isPathAllowed(cwd))
+            return { success: false, error: "Access denied: Path is outside the allowed workspace." };
         const run = async (cmd) => {
             try {
                 const { stdout } = await execAsync(cmd, { cwd });
@@ -414,6 +535,8 @@ export const linter = {
     description: 'Lint a file',
     inputSchema: z.object({ path: z.string() }),
     execute: async ({ path }) => {
+        if (!isPathAllowed(path))
+            return { passed: false, errors: [{ message: 'Access denied: Path is outside the allowed workspace.' }] };
         if (!existsSync(path))
             return { passed: false, errors: [{ message: 'File not found' }] };
         const ext = extname(path);
@@ -478,4 +601,258 @@ export const getTrackedFiles = async (cwd) => {
         return [];
     }
 };
-export const allBuiltins = [readFiles, writeFiles, createTool, scrapeUrl, listFiles, searchFiles, listDir, runCommand, deleteFile, gitTool, linter];
+// --- Meta-Orchestrator Tools ---
+export const delegate_cli = {
+    name: 'delegate_cli',
+    description: 'Delegate a complex task to a specialized external CLI agent (Codex, Gemini, Claude).',
+    inputSchema: z.object({
+        cli: z.string(),
+        task: z.string(),
+        context_files: z.array(z.string()).optional(),
+        async: z.boolean().default(false).describe("Run in background mode. Returns a Task ID to monitor.")
+    }),
+    execute: async ({ cli, task, context_files, async }) => {
+        try {
+            console.log(`[delegate_cli] Spawning external process for ${cli}...`);
+            const config = await loadConfig();
+            // Default to mock if no config for this agent
+            if (!config.agents || !config.agents[cli]) {
+                console.warn(`[delegate_cli] No configuration found for '${cli}'. Falling back to mock.`);
+                const cmd = `npx tsx tests/manual_scripts/mock_cli.ts "${task}"`;
+                const { stdout, stderr } = await execAsync(cmd);
+                if (stderr)
+                    console.warn(`[delegate_cli] Stderr: ${stderr}`);
+                return `[${cli} CLI (Mock)]:\n${stdout.trim()}`;
+            }
+            const agent = config.agents[cli];
+            const cmdArgs = [...(agent.args || []), task];
+            // Handle file arguments for agents that don't support stdin or use --file flags
+            if (!agent.supports_stdin && context_files && context_files.length > 0) {
+                for (const file of context_files) {
+                    if (!isPathAllowed(file)) {
+                        console.warn(`[delegate_cli] Skipped restricted file: ${file}`);
+                        continue;
+                    }
+                    const flag = agent.context_flag !== undefined ? agent.context_flag : '--file';
+                    if (flag) {
+                        cmdArgs.push(flag, file);
+                    }
+                    else {
+                        cmdArgs.push(file);
+                    }
+                }
+            }
+            const child = spawn(agent.command, cmdArgs, {
+                env: { ...process.env, ...agent.env },
+                shell: false // Use false for safer arg handling, unless command relies on shell features
+            });
+            // Async Mode Handling
+            if (async) {
+                // Determine command to run for AsyncTaskManager
+                // We need to reconstruct the full command string for AsyncTaskManager or pass args
+                // Actually AsyncTaskManager takes command and args.
+                // But we already spawned 'child' here? 
+                // Wait, if async, we shouldn't spawn here and wait. 
+                // We should delegate the spawning to AsyncTaskManager.
+                // Let's refactor:
+                child.kill(); // Kill the one we just started (oops, inefficient but safe if we didn't write stdin yet)
+                // Actually, let's just use AsyncTaskManager INSTEAD of spawning manually.
+                const taskManager = AsyncTaskManager.getInstance();
+                // Prepare context file content to pass as environment variable or temp file 
+                // if the agent expects stdin. 
+                // AsyncTaskManager runs detached, so we can't easily pipe stdin unless we wrap it.
+                // For simplicity, if async is requested, we might only support 'context_files' passed as args.
+                // If agent requires stdin, we can write a temporary input file and pipe it:
+                // cmd: "cat input.txt | agent ..."
+                // This is getting complex for 'generic' agents.
+                // Strategy: Just run the agent command. If it needs context files, they are in cmdArgs.
+                // If it needs stdin, we warn or skip for now in async mode unless we implement 'input_file' support.
+                if (agent.supports_stdin && context_files && context_files.length > 0) {
+                    return `[delegate_cli] Warning: Async mode with Stdin context is not fully supported yet. Please use 'async: false' or ensure agent accepts files via arguments.`;
+                }
+                const id = await taskManager.startTask(agent.command, cmdArgs, agent.env);
+                return `[delegate_cli] Async Task Started.\nID: ${id}\nMonitor status using 'check_task_status'.`;
+            }
+            // Sync Mode (Existing Logic)
+            // Handle Stdin Context Injection
+            if (agent.supports_stdin && context_files && context_files.length > 0) {
+                // Read files and pipe to stdin
+                // Format: --- filename ---\n content \n ---
+                let context = "";
+                for (const file of context_files) {
+                    if (!isPathAllowed(file)) {
+                        console.warn(`[delegate_cli] Skipped restricted file: ${file}`);
+                        continue;
+                    }
+                    if (existsSync(file)) {
+                        const content = await readFile(file, 'utf-8');
+                        context += `--- ${file} ---\n${content}\n\n`;
+                    }
+                }
+                child.stdin.write(context);
+                child.stdin.end();
+            }
+            else {
+                child.stdin.end();
+            }
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', d => stdout += d.toString());
+            child.stderr.on('data', d => stderr += d.toString());
+            return new Promise((resolve, reject) => {
+                child.on('close', code => {
+                    if (stderr)
+                        console.warn(`[delegate_cli] Stderr: ${stderr}`);
+                    if (code === 0) {
+                        resolve(`[${cli} CLI]:\n${stdout.trim()}`);
+                    }
+                    else {
+                        resolve(`[${cli} CLI] Process exited with code ${code}.\nOutput: ${stdout}\nError: ${stderr}`);
+                    }
+                });
+                child.on('error', (err) => {
+                    resolve(`[${cli} CLI] Failed to start process: ${err.message}`);
+                });
+            });
+        }
+        catch (e) {
+            return `[${cli} CLI]: Error executing external process: ${e.message}`;
+        }
+    }
+};
+export const schedule_task = {
+    name: 'schedule_task',
+    description: 'Register a recurring task to be executed by the agent autonomously.',
+    inputSchema: z.object({
+        cron: z.string().describe('Standard cron expression (e.g. "0 9 * * *")'),
+        prompt: z.string().describe('The instruction to execute'),
+        description: z.string().describe('Human-readable description')
+    }),
+    execute: async ({ cron, prompt, description }) => {
+        try {
+            const scheduler = Scheduler.getInstance();
+            const id = await scheduler.scheduleTask(cron, prompt, description);
+            return `Task scheduled successfully with ID: ${id}`;
+        }
+        catch (e) {
+            return `Failed to schedule task: ${e.message}`;
+        }
+    }
+};
+export const pr_list = {
+    name: 'pr_list',
+    description: 'List open pull requests',
+    inputSchema: z.object({ limit: z.number().default(10) }),
+    execute: async ({ limit }) => {
+        try {
+            const { stdout } = await execAsync(`gh pr list --limit ${limit}`);
+            return stdout.trim() || 'No open PRs found.';
+        }
+        catch (e) {
+            return `Error listing PRs: ${e.message}`;
+        }
+    }
+};
+export const pr_review = {
+    name: 'pr_review',
+    description: 'Get the diff/details of a PR',
+    inputSchema: z.object({ pr_number: z.number() }),
+    execute: async ({ pr_number }) => {
+        try {
+            const { stdout } = await execAsync(`gh pr diff ${pr_number}`);
+            return stdout.trim();
+        }
+        catch (e) {
+            return `Error reviewing PR ${pr_number}: ${e.message}`;
+        }
+    }
+};
+export const pr_comment = {
+    name: 'pr_comment',
+    description: 'Add a comment to a PR (e.g., to instruct Jules to fix something).',
+    inputSchema: z.object({
+        pr_number: z.number(),
+        body: z.string()
+    }),
+    execute: async ({ pr_number, body }) => {
+        try {
+            await execAsync(`gh pr comment ${pr_number} --body "${body}"`);
+            return `Commented on PR ${pr_number}: "${body}"`;
+        }
+        catch (e) {
+            return `Error commenting on PR ${pr_number}: ${e.message}`;
+        }
+    }
+};
+export const pr_ready = {
+    name: 'pr_ready',
+    description: 'Mark a Draft PR as Ready for Review',
+    inputSchema: z.object({ pr_number: z.number() }),
+    execute: async ({ pr_number }) => {
+        try {
+            await execAsync(`gh pr ready ${pr_number}`);
+            return `PR ${pr_number} marked as Ready for Review`;
+        }
+        catch (e) {
+            return `Error marking PR ${pr_number} as ready: ${e.message}`;
+        }
+    }
+};
+export const pr_merge = {
+    name: 'pr_merge',
+    description: 'Merge a pull request',
+    inputSchema: z.object({
+        pr_number: z.number(),
+        method: z.enum(['merge', 'squash', 'rebase']).default('merge')
+    }),
+    execute: async ({ pr_number, method }) => {
+        try {
+            await execAsync(`gh pr merge ${pr_number} --${method} --delete-branch`);
+            return `Successfully merged PR ${pr_number}`;
+        }
+        catch (e) {
+            return `Error merging PR ${pr_number}: ${e.message}`;
+        }
+    }
+};
+export const check_task_status = {
+    name: 'check_task_status',
+    description: 'Check the status and logs of a background task.',
+    inputSchema: z.object({
+        id: z.string().describe('The Task ID returned by delegate_cli')
+    }),
+    execute: async ({ id }) => {
+        try {
+            const manager = AsyncTaskManager.getInstance();
+            const task = await manager.getTaskStatus(id);
+            const logs = await manager.getTaskLogs(id, 5); // Last 5 lines
+            return `Task ID: ${task.id}
+Status: ${task.status}
+PID: ${task.pid}
+Last Logs:
+${logs}
+`;
+        }
+        catch (e) {
+            return `Error checking task ${id}: ${e.message}`;
+        }
+    }
+};
+export const list_bg_tasks = {
+    name: 'list_bg_tasks',
+    description: 'List all background tasks.',
+    inputSchema: z.object({}),
+    execute: async () => {
+        try {
+            const manager = AsyncTaskManager.getInstance();
+            const tasks = await manager.listTasks();
+            if (tasks.length === 0)
+                return "No background tasks found.";
+            return tasks.map(t => `- [${t.status.toUpperCase()}] ${t.id}: ${t.command} (Started: ${new Date(t.startTime).toISOString()})`).join('\n');
+        }
+        catch (e) {
+            return `Error listing tasks: ${e.message}`;
+        }
+    }
+};
+export const allBuiltins = [readFiles, writeFiles, createTool, scrapeUrl, listFiles, searchFiles, listDir, runCommand, stopCommand, deleteFile, gitTool, linter, delegate_cli, schedule_task, check_task_status, list_bg_tasks, pr_list, pr_review, pr_comment, pr_ready, pr_merge];

package/dist/claw/jit.d.ts

@@ -0,0 +1,5 @@
+/**
+ * [Simple-CLI AI-Created]
+ * Recreated file based on task description.
+ */
+export declare function buildMemoryContext(reflectionsDir: string, files: string[]): Promise<string>;

package/dist/claw/jit.js

@@ -0,0 +1,14 @@
+import { readFile } from 'fs/promises';
+import * as path from 'path';
+/**
+ * [Simple-CLI AI-Created]
+ * Recreated file based on task description.
+ */
+export async function buildMemoryContext(reflectionsDir, files) {
+    // Optimized: Concurrent non-blocking reads using Promise.all
+    const contents = await Promise.all(files.map(async (f) => {
+        const content = await readFile(path.join(reflectionsDir, f), 'utf-8');
+        return `\n--- Previous Reflection (${f}) ---\n${content}\n`;
+    }));
+    return contents.join('');
+}

package/dist/cli.js

@@ -7,17 +7,25 @@ import { createLLM } from './llm.js';
 import { MCP } from './mcp.js';
 import { getActiveSkill } from './skills.js';
 import { showBanner } from './tui.js';
+import { Scheduler } from './scheduler.js';
+import { log, outro } from '@clack/prompts';
 async function main() {
     const args = process.argv.slice(2);
     // Handle optional directory argument
     let cwd = process.cwd();
     let interactive = true;
+    let daemon = false;
     const remainingArgs = [];
     for (const arg of args) {
         if (arg === '--non-interactive') {
             interactive = false;
             continue;
         }
+        if (arg === '--daemon') {
+            daemon = true;
+            interactive = false;
+            continue;
+        }
         if (!arg.startsWith('-')) {
             try {
                 if (statSync(arg).isDirectory()) {
@@ -37,9 +45,52 @@ async function main() {
     const mcp = new MCP();
     const provider = createLLM();
     const engine = new Engine(provider, registry, mcp);
-    const skill = await getActiveSkill(cwd);
-    const ctx = new Context(cwd, skill);
-    showBanner();
-    await engine.run(ctx, prompt || undefined, { interactive });
+    // --- Scheduler Integration ---
+    const scheduler = Scheduler.getInstance(cwd);
+    const processDueTasks = async () => {
+        const dueTasks = await scheduler.getDueTasks();
+        if (dueTasks.length > 0) {
+            log.info(`Found ${dueTasks.length} scheduled tasks due.`);
+            for (const task of dueTasks) {
+                log.step(`Running task: ${task.description} (${task.cron})`);
+                // Use a fresh context for each task
+                const taskCtx = new Context(cwd, await getActiveSkill(cwd));
+                try {
+                    // Run non-interactively
+                    await engine.run(taskCtx, task.prompt, { interactive: false });
+                    await scheduler.markTaskRun(task.id, true);
+                    log.success(`Task ${task.id} completed.`);
+                }
+                catch (e) {
+                    log.error(`Task ${task.id} failed: ${e.message}`);
+                    await scheduler.markTaskRun(task.id, false);
+                }
+            }
+            log.info('All scheduled tasks processed.');
+        }
+    };
+    if (daemon) {
+        showBanner();
+        log.info('Running in daemon mode. Checking for tasks every 60s...');
+        while (true) {
+            try {
+                await processDueTasks();
+            }
+            catch (e) {
+                log.error(`Error in daemon loop: ${e.message}`);
+            }
+            // Sleep for 60 seconds
+            await new Promise(resolve => setTimeout(resolve, 60000));
+        }
+    }
+    else {
+        showBanner();
+        // Standard run: check tasks once, then interactive
+        await processDueTasks();
+        const skill = await getActiveSkill(cwd);
+        const ctx = new Context(cwd, skill);
+        await engine.run(ctx, prompt || undefined, { interactive });
+        outro('Session finished.');
+    }
 }
 main().catch(console.error);

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+export interface AgentConfig {
+    command: string;
+    args: string[];
+    description: string;
+    supports_stdin?: boolean;
+    env?: Record<string, string>;
+    context_flag?: string;
+}
+export interface TaskConfig {
+    id: string;
+    cron: string;
+    command: string;
+    description: string;
+    enabled?: boolean;
+}
+export interface SchedulerConfig {
+    enabled: boolean;
+    tasks: TaskConfig[];
+}
+export interface Config {
+    mcpServers?: Record<string, any>;
+    agents?: Record<string, AgentConfig>;
+    scheduler?: SchedulerConfig;
+    yoloMode?: boolean;
+    autoDecisionTimeout?: number;
+}
+export declare function loadConfig(cwd?: string): Promise<Config>;

package/dist/config.js

@@ -0,0 +1,21 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+export async function loadConfig(cwd = process.cwd()) {
+    const locations = [
+        join(cwd, 'mcp.json'),
+        join(cwd, '.agent', 'config.json')
+    ];
+    for (const loc of locations) {
+        if (existsSync(loc)) {
+            try {
+                const content = await readFile(loc, 'utf-8');
+                return JSON.parse(content);
+            }
+            catch (e) {
+                console.error(`Failed to parse config at ${loc}:`, e);
+            }
+        }
+    }
+    return {};
+}