@stan-chen/simple-cli 0.2.3 → 0.2.5

package/dist/tools/run_command.js

@@ -1,103 +0,0 @@
-/**
- * Tool: runCommand
- * Execute shell commands in a sandboxed environment
- */
-import { spawn } from 'child_process';
-import { z } from 'zod';
-export const name = 'run_command';
-export const description = 'Execute a shell command with timeout and environment restrictions';
-export const permission = 'execute';
-export const schema = z.object({
-    command: z.string().describe('The shell command to execute'),
-    cwd: z.string().optional().describe('Working directory for the command'),
-    timeout: z.number().optional().describe('Timeout in milliseconds (default: 30000)'),
-    env: z.record(z.string()).optional().describe('Additional environment variables')
-});
-// Restricted environment - remove sensitive variables
-const createSafeEnv = (additionalEnv) => {
-    // Start from a minimal safe copy to avoid leaking secrets
-    const rawEnv = { ...process.env };
-    const sensitivePattern = /(API_KEY$|_KEY$|TOKEN|SECRET|PASSWORD|VLM_API|OPENAI_API|GEMINI_API|NPM_ACCESS_TOKEN)/i;
-    const env = {};
-    for (const [k, v] of Object.entries(rawEnv)) {
-        if (!k)
-            continue;
-        if (sensitivePattern.test(k))
-            continue; // skip sensitive keys
-        env[k] = v;
-    }
-    // Add any additional env vars provided explicitly, but still filter them
-    if (additionalEnv) {
-        for (const [k, v] of Object.entries(additionalEnv)) {
-            if (!k)
-                continue;
-            if (sensitivePattern.test(k))
-                continue; // never allow sensitive keys
-            env[k] = v;
-        }
-    }
-    return env;
-};
-export const execute = async (args) => {
-    const parsed = schema.parse(args);
-    const timeout = parsed.timeout || 30000;
-    const env = createSafeEnv(parsed.env);
-    return new Promise((resolve) => {
-        let stdout = '';
-        let stderr = '';
-        let timedOut = false;
-        // Quick heuristic: detect obviously unbalanced quotes and treat as syntax error
-        const singleQuotes = (parsed.command.match(/'/g) || []).length;
-        const doubleQuotes = (parsed.command.match(/"/g) || []).length;
-        if (singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0) {
-            return resolve({ exitCode: 1, stdout: '', stderr: 'Invalid shell syntax (unbalanced quotes)', timedOut: false });
-        }
-        const child = spawn(parsed.command, {
-            shell: true,
-            cwd: parsed.cwd || process.cwd(),
-            env,
-            stdio: ['ignore', 'pipe', 'pipe']
-        });
-        const timer = setTimeout(() => {
-            timedOut = true;
-            child.kill('SIGTERM');
-            setTimeout(() => child.kill('SIGKILL'), 1000);
-        }, timeout);
-        child.stdout?.on('data', (data) => {
-            stdout += data.toString();
-            // Limit output size
-            if (stdout.length > 100000) {
-                stdout = stdout.slice(0, 100000) + '\n... (output truncated)';
-                child.kill('SIGTERM');
-            }
-        });
-        child.stderr?.on('data', (data) => {
-            stderr += data.toString();
-            if (stderr.length > 50000) {
-                stderr = stderr.slice(0, 50000) + '\n... (output truncated)';
-            }
-        });
-        child.on('close', (code) => {
-            clearTimeout(timer);
-            // If command failed but provided no stderr, include the command for diagnostics
-            if ((code ?? 0) !== 0 && !stderr) {
-                stderr = `Command failed: ${parsed.command}`;
-            }
-            resolve({
-                exitCode: code ?? 1,
-                stdout: stdout.trim(),
-                stderr: stderr.trim(),
-                timedOut
-            });
-        });
-        child.on('error', (error) => {
-            clearTimeout(timer);
-            resolve({
-                exitCode: 1,
-                stdout: '',
-                stderr: error.message,
-                timedOut: false
-            });
-        });
-    });
-};

package/dist/tools/scheduler.d.ts

@@ -1,25 +0,0 @@
-/**
- * Tool: scheduler
- * Manage Ghost Tasks (scheduled executions) using crontab or schtasks
- */
-import { z } from 'zod';
-export declare const name = "scheduler";
-export declare const description = "Schedule a task to run automatically at intervals. CRITICAL for fulfilling \"Every X minutes\" or \"Every day\" intents. Tasks run in --ghost mode.";
-export declare const permission: "execute";
-export declare const schema: z.ZodObject<{
-    intent: z.ZodString;
-    schedule: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    targetDir: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    intent: string;
-    schedule: string;
-    name?: string | undefined;
-    targetDir?: string | undefined;
-}, {
-    intent: string;
-    schedule: string;
-    name?: string | undefined;
-    targetDir?: string | undefined;
-}>;
-export declare const execute: (args: Record<string, unknown>) => Promise<string>;

package/dist/tools/scheduler.js

@@ -1,65 +0,0 @@
-/**
- * Tool: scheduler
- * Manage Ghost Tasks (scheduled executions) using crontab or schtasks
- */
-import { execSync } from 'child_process';
-import { platform } from 'os';
-import { z } from 'zod';
-import { resolve, join } from 'path';
-export const name = 'scheduler';
-export const description = 'Schedule a task to run automatically at intervals. CRITICAL for fulfilling "Every X minutes" or "Every day" intents. Tasks run in --ghost mode.';
-export const permission = 'execute';
-export const schema = z.object({
-    intent: z.string().describe('The task description/intent to execute'),
-    schedule: z.string().describe('Cron expression (e.g. "0 * * * *") or interval in minutes'),
-    name: z.string().optional().describe('Unique name for the task'),
-    targetDir: z.string().optional().describe('Working directory for the task')
-});
-export const execute = async (args) => {
-    const { intent, schedule, name: taskName, targetDir } = schema.parse(args);
-    const isWindows = platform() === 'win32';
-    const cwd = resolve(targetDir || process.cwd());
-    const id = taskName || `ghost-${Date.now()}`;
-    // Path to simple-cli. We assume it's installed globally or use the current one.
-    // For local dev, we use the absolute path to dist/cli.js
-    const cliPath = resolve(join(process.cwd(), 'dist', 'cli.js'));
-    const command = `node "${cliPath}" "${cwd}" -claw "${intent}" --ghost --yolo`;
-    try {
-        if (isWindows) {
-            const interval = parseInt(schedule) || 60;
-            const escapedCommand = command.replace(/"/g, '\\"');
-            try {
-                execSync(`schtasks /create /sc minute /mo ${interval} /tn "${id}" /tr "${escapedCommand}" /f`);
-                return `Task scheduled on Windows: ${id} Every ${interval} minutes.`;
-            }
-            catch (e) {
-                return `Error scheduling on Windows: ${e.message}`;
-            }
-        }
-        else {
-            try {
-                // Determine cron expression
-                let cronExpr = schedule;
-                if (!schedule.includes('*')) {
-                    const mins = parseInt(schedule) || 60;
-                    cronExpr = `*/${mins} * * * *`;
-                }
-                const cronEntry = `${cronExpr} ${command} # ${id}`;
-                let currentCron = '';
-                try {
-                    currentCron = execSync('crontab -l', { encoding: 'utf-8' });
-                }
-                catch (e) { /* ignore empty crontab */ }
-                const newCron = currentCron.trim() + '\n' + cronEntry + '\n';
-                execSync(`echo "${newCron}" | crontab -`);
-                return `Task scheduled on Linux/Mac: ${id} with schedule ${cronExpr}`;
-            }
-            catch (e) {
-                return `Error scheduling on Linux/Mac: ${e.message}`;
-            }
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to schedule task: ${error instanceof Error ? error.message : error}`);
-    }
-};

package/dist/tools/scraper.d.ts

@@ -1,31 +0,0 @@
-/**
- * Web Scraper Tool - Fetches and converts web content to markdown
- * Uses turndown for robust HTML to Markdown conversion (with regex fallback)
- */
-import { z } from 'zod';
-import type { Tool } from '../registry.js';
-export declare const inputSchema: z.ZodObject<{
-    url: z.ZodString;
-    convertToMarkdown: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    verifySSL: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, "strip", z.ZodTypeAny, {
-    url: string;
-    timeout: number;
-    convertToMarkdown: boolean;
-    verifySSL: boolean;
-}, {
-    url: string;
-    timeout?: number | undefined;
-    convertToMarkdown?: boolean | undefined;
-    verifySSL?: boolean | undefined;
-}>;
-type ScraperInput = z.infer<typeof inputSchema>;
-export declare function execute(input: ScraperInput): Promise<{
-    url: string;
-    content: string;
-    contentType: string;
-    error?: string;
-}>;
-export declare const tool: Tool;
-export {};

package/dist/tools/scraper.js

@@ -1,211 +0,0 @@
-/**
- * Web Scraper Tool - Fetches and converts web content to markdown
- * Uses turndown for robust HTML to Markdown conversion (with regex fallback)
- */
-import { z } from 'zod';
-// Input schema
-export const inputSchema = z.object({
-    url: z.string().url().describe('URL to scrape'),
-    convertToMarkdown: z.boolean().optional().default(true).describe('Convert HTML to Markdown'),
-    verifySSL: z.boolean().optional().default(true).describe('Verify SSL certificates'),
-    timeout: z.number().optional().default(30000).describe('Timeout in milliseconds'),
-});
-// Cached turndown instance
-let turndownInstance = null;
-let turndownLoaded = false;
-// Get or create turndown instance (lazy load)
-async function getTurndown() {
-    if (!turndownLoaded) {
-        turndownLoaded = true;
-        try {
-            const mod = await import('turndown');
-            const TurndownService = mod.default;
-            turndownInstance = new TurndownService({
-                headingStyle: 'atx',
-                hr: '---',
-                bulletListMarker: '-',
-                codeBlockStyle: 'fenced',
-                emDelimiter: '*',
-                strongDelimiter: '**',
-                linkStyle: 'inlined',
-            });
-            // Remove script and style elements
-            turndownInstance.remove(['script', 'style', 'noscript', 'iframe', 'svg']);
-            // Custom rule for code blocks with language hints
-            turndownInstance.addRule('codeBlock', {
-                filter: (node) => {
-                    return (node.nodeName === 'PRE' &&
-                        node.firstChild !== null &&
-                        node.firstChild.nodeName === 'CODE');
-                },
-                replacement: (_content, node) => {
-                    const codeNode = node.firstChild;
-                    const className = codeNode.getAttribute?.('class') || '';
-                    const langMatch = className.match(/language-(\w+)/);
-                    const lang = langMatch ? langMatch[1] : '';
-                    const code = codeNode.textContent || '';
-                    return `\n\n\`\`\`${lang}\n${code.trim()}\n\`\`\`\n\n`;
-                },
-            });
-        }
-        catch {
-            // turndown not installed, will use fallback
-        }
-    }
-    return turndownInstance;
-}
-// Fallback regex-based HTML to Markdown conversion
-function htmlToMarkdownFallback(html) {
-    let md = html;
-    // Remove script and style tags
-    md = md.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');
-    md = md.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '');
-    // Convert headings
-    md = md.replace(/<h1[^>]*>(.*?)<\/h1>/gi, '\n# $1\n');
-    md = md.replace(/<h2[^>]*>(.*?)<\/h2>/gi, '\n## $1\n');
-    md = md.replace(/<h3[^>]*>(.*?)<\/h3>/gi, '\n### $1\n');
-    md = md.replace(/<h4[^>]*>(.*?)<\/h4>/gi, '\n#### $1\n');
-    md = md.replace(/<h5[^>]*>(.*?)<\/h5>/gi, '\n##### $1\n');
-    md = md.replace(/<h6[^>]*>(.*?)<\/h6>/gi, '\n###### $1\n');
-    // Convert paragraphs
-    md = md.replace(/<p[^>]*>(.*?)<\/p>/gis, '\n$1\n');
-    // Convert links
-    md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, '[$2]($1)');
-    // Convert images
-    md = md.replace(/<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, '![$2]($1)');
-    md = md.replace(/<img[^>]*src="([^"]*)"[^>]*\/?>/gi, '![]($1)');
-    // Convert bold
-    md = md.replace(/<strong[^>]*>(.*?)<\/strong>/gi, '**$1**');
-    md = md.replace(/<b[^>]*>(.*?)<\/b>/gi, '**$1**');
-    // Convert italic
-    md = md.replace(/<em[^>]*>(.*?)<\/em>/gi, '*$1*');
-    md = md.replace(/<i[^>]*>(.*?)<\/i>/gi, '*$1*');
-    // Convert inline code
-    md = md.replace(/<code[^>]*>(.*?)<\/code>/gi, '`$1`');
-    // Convert code blocks
-    md = md.replace(/<pre[^>]*><code[^>]*>(.*?)<\/code><\/pre>/gis, '\n```\n$1\n```\n');
-    md = md.replace(/<pre[^>]*>(.*?)<\/pre>/gis, '\n```\n$1\n```\n');
-    // Convert lists
-    md = md.replace(/<ul[^>]*>(.*?)<\/ul>/gis, (_, content) => {
-        return content.replace(/<li[^>]*>(.*?)<\/li>/gi, '- $1\n');
-    });
-    md = md.replace(/<ol[^>]*>(.*?)<\/ol>/gis, (_, content) => {
-        let i = 1;
-        return content.replace(/<li[^>]*>(.*?)<\/li>/gi, () => `${i++}. $1\n`);
-    });
-    // Convert blockquotes
-    md = md.replace(/<blockquote[^>]*>(.*?)<\/blockquote>/gis, (_, content) => {
-        return content.split('\n').map((line) => `> ${line}`).join('\n');
-    });
-    // Convert line breaks
-    md = md.replace(/<br\s*\/?>/gi, '\n');
-    // Convert horizontal rules
-    md = md.replace(/<hr\s*\/?>/gi, '\n---\n');
-    // Remove remaining HTML tags
-    md = md.replace(/<[^>]+>/g, '');
-    // Decode HTML entities
-    md = md.replace(/&nbsp;/g, ' ');
-    md = md.replace(/&amp;/g, '&');
-    md = md.replace(/&lt;/g, '<');
-    md = md.replace(/&gt;/g, '>');
-    md = md.replace(/&quot;/g, '"');
-    md = md.replace(/&#39;/g, "'");
-    // Clean up whitespace
-    md = md.replace(/\n{3,}/g, '\n\n');
-    md = md.trim();
-    return md;
-}
-// Slim down HTML by removing unnecessary elements before conversion
-function slimDownHtml(html) {
-    let slim = html;
-    // Remove SVG elements
-    slim = slim.replace(/<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>/gi, '');
-    // Remove data: URLs (large embedded content)
-    slim = slim.replace(/\s*(?:href|src)=["']data:[^"']*["']/gi, '');
-    // Remove inline styles
-    slim = slim.replace(/\s*style=["'][^"']*["']/gi, '');
-    // Remove tracking pixels and tiny images
-    slim = slim.replace(/<img[^>]*(?:width|height)=["']?[01](?:px)?["']?[^>]*>/gi, '');
-    return slim;
-}
-// Check if content looks like HTML
-function looksLikeHtml(content) {
-    const htmlPatterns = [
-        /<!DOCTYPE\s+html/i,
-        /<html/i,
-        /<head/i,
-        /<body/i,
-        /<div/i,
-        /<p>/i,
-        /<a\s+href=/i,
-    ];
-    return htmlPatterns.some(pattern => pattern.test(content));
-}
-// Convert HTML to Markdown using turndown or fallback
-async function htmlToMarkdown(html) {
-    const turndown = await getTurndown();
-    if (turndown) {
-        try {
-            return turndown.turndown(html);
-        }
-        catch {
-            // Fall through to regex fallback
-        }
-    }
-    return htmlToMarkdownFallback(html);
-}
-// Execute scraping
-export async function execute(input) {
-    const { url, convertToMarkdown, verifySSL, timeout } = inputSchema.parse(input);
-    try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        const response = await fetch(url, {
-            signal: controller.signal,
-            headers: {
-                'User-Agent': 'simplecli/0.2.1 (+https://github.com/stancsz/simple-cli)',
-                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-            },
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-            return {
-                url,
-                content: '',
-                contentType: '',
-                error: `HTTP ${response.status}: ${response.statusText}`,
-            };
-        }
-        const contentType = response.headers.get('content-type') || '';
-        let content = await response.text();
-        // Convert HTML to Markdown if requested
-        if (convertToMarkdown && (contentType.includes('text/html') || looksLikeHtml(content))) {
-            content = slimDownHtml(content);
-            content = await htmlToMarkdown(content);
-            // Clean up excessive whitespace
-            content = content.replace(/\n{3,}/g, '\n\n').trim();
-        }
-        return {
-            url,
-            content,
-            contentType,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            url,
-            content: '',
-            contentType: '',
-            error: errorMessage.includes('abort') ? 'Request timed out' : errorMessage,
-        };
-    }
-}
-// Tool definition
-export const tool = {
-    name: 'scrapeUrl',
-    description: 'Fetch a URL and convert its content to markdown. Useful for reading web pages, documentation, or API responses.',
-    inputSchema,
-    permission: 'read',
-    execute: async (args) => execute(args),
-};

package/dist/tools/writeFiles.d.ts

@@ -1,63 +0,0 @@
-/**
- * Tool: writeFiles
- * Write or update files with search/replace support (Aider-style)
- */
-import { z } from 'zod';
-export declare const name = "writeFiles";
-export declare const description = "Write or modify files. ALWAYS provide an array of objects in the \"files\" parameter, even for a single file. Each object must have \"path\" and either \"content\" (for full write) or \"searchReplace\" (for edits).";
-export declare const permission: "write";
-export declare const schema: z.ZodObject<{
-    files: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        content: z.ZodOptional<z.ZodString>;
-        searchReplace: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            search: z.ZodString;
-            replace: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            replace: string;
-            search: string;
-        }, {
-            replace: string;
-            search: string;
-        }>, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        path: string;
-        content?: string | undefined;
-        searchReplace?: {
-            replace: string;
-            search: string;
-        }[] | undefined;
-    }, {
-        path: string;
-        content?: string | undefined;
-        searchReplace?: {
-            replace: string;
-            search: string;
-        }[] | undefined;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    files: {
-        path: string;
-        content?: string | undefined;
-        searchReplace?: {
-            replace: string;
-            search: string;
-        }[] | undefined;
-    }[];
-}, {
-    files: {
-        path: string;
-        content?: string | undefined;
-        searchReplace?: {
-            replace: string;
-            search: string;
-        }[] | undefined;
-    }[];
-}>;
-interface WriteResult {
-    path: string;
-    success: boolean;
-    message: string;
-}
-export declare const execute: (args: Record<string, unknown>) => Promise<WriteResult[]>;
-export {};

package/dist/tools/writeFiles.js

@@ -1,87 +0,0 @@
-/**
- * Tool: writeFiles
- * Write or update files with search/replace support (Aider-style)
- */
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { dirname, resolve } from 'path';
-import { z } from 'zod';
-export const name = 'writeFiles';
-export const description = 'Write or modify files. ALWAYS provide an array of objects in the "files" parameter, even for a single file. Each object must have "path" and either "content" (for full write) or "searchReplace" (for edits).';
-export const permission = 'write';
-const FileWriteSchema = z.object({
-    path: z.string().describe('File path to write'),
-    content: z.string().optional().describe('Full content to write (for new files or full rewrites)'),
-    searchReplace: z.array(z.object({
-        search: z.string().describe('Text to search for'),
-        replace: z.string().describe('Text to replace with')
-    })).optional().describe('Array of search/replace operations for targeted edits')
-});
-export const schema = z.object({
-    files: z.array(FileWriteSchema).describe('Array of files to write/modify')
-});
-export const execute = async (args) => {
-    const parsed = schema.parse(args);
-    const results = [];
-    for (const file of parsed.files) {
-        try {
-            // Ensure directory exists
-            await mkdir(dirname(file.path), { recursive: true });
-            if (file.content !== undefined) {
-                // Full file write
-                await writeFile(file.path, file.content, 'utf-8');
-                const absPath = resolve(file.path);
-                results.push({
-                    path: file.path,
-                    success: true,
-                    message: `File written successfully to ${absPath}`
-                });
-            }
-            else if (file.searchReplace && file.searchReplace.length > 0) {
-                // Search/replace operations
-                let content = await readFile(file.path, 'utf-8');
-                let changesApplied = 0;
-                const absPath = resolve(file.path);
-                for (const { search, replace } of file.searchReplace) {
-                    if (content.includes(search)) {
-                        // Apply replacement to all occurrences
-                        const newContent = content.replace(search, replace);
-                        if (newContent !== content) {
-                            content = newContent;
-                            changesApplied++;
-                        }
-                    }
-                }
-                if (changesApplied > 0) {
-                    await writeFile(file.path, content, 'utf-8');
-                    results.push({
-                        path: file.path,
-                        success: true,
-                        message: `Applied ${changesApplied} search/replace operation(s) to ${absPath}`
-                    });
-                }
-                else {
-                    results.push({
-                        path: file.path,
-                        success: false,
-                        message: `No matching search patterns found in ${absPath}`
-                    });
-                }
-            }
-            else {
-                results.push({
-                    path: file.path,
-                    success: false,
-                    message: 'No content or searchReplace provided'
-                });
-            }
-        }
-        catch (error) {
-            results.push({
-                path: file.path,
-                success: false,
-                message: error instanceof Error ? error.message : 'Unknown error'
-            });
-        }
-    }
-    return results;
-};

package/dist/tools/write_files.d.ts

@@ -1,84 +0,0 @@
-/**
- * Tool: writeFiles
- * Write or update files with search/replace support (Aider-style)
- */
-import { z } from 'zod';
-export declare const name = "write_files";
-export declare const description = "Write or modify files. ALWAYS provide an array of objects in the \"files\" parameter, even for a single file. Each object must have \"path\" and either \"content\" (for full write) or \"searchReplace\" (for edits).";
-export declare const permission: "write";
-export declare const schema: z.ZodObject<{
-    files: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        content: z.ZodOptional<z.ZodString>;
-        searchReplace: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodObject<{
-            search: z.ZodString;
-            replace: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            replace: string;
-            search: string;
-        }, {
-            replace: string;
-            search: string;
-        }>, "many">, z.ZodEffects<z.ZodObject<{
-            search: z.ZodString;
-            replace: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            replace: string;
-            search: string;
-        }, {
-            replace: string;
-            search: string;
-        }>, {
-            replace: string;
-            search: string;
-        }[], {
-            replace: string;
-            search: string;
-        }>]>>;
-    }, "strip", z.ZodTypeAny, {
-        path: string;
-        content?: string | undefined;
-        searchReplace?: {
-            replace: string;
-            search: string;
-        }[] | undefined;
-    }, {
-        path: string;
-        content?: string | undefined;
-        searchReplace?: {
-            replace: string;
-            search: string;
-        } | {
-            replace: string;
-            search: string;
-        }[] | undefined;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    files: {
-        path: string;
-        content?: string | undefined;
-        searchReplace?: {
-            replace: string;
-            search: string;
-        }[] | undefined;
-    }[];
-}, {
-    files: {
-        path: string;
-        content?: string | undefined;
-        searchReplace?: {
-            replace: string;
-            search: string;
-        } | {
-            replace: string;
-            search: string;
-        }[] | undefined;
-    }[];
-}>;
-interface WriteResult {
-    path: string;
-    success: boolean;
-    message: string;
-}
-export declare const execute: (args: Record<string, unknown>) => Promise<WriteResult[]>;
-export {};