@stan-chen/simple-cli 0.2.1 → 0.2.3

package/dist/tools/linter.js

@@ -6,6 +6,7 @@ import { z } from 'zod';
 import { execSync, spawnSync } from 'child_process';
 import { readFileSync, existsSync } from 'fs';
 import { extname, basename } from 'path';
+import { platform } from 'os';
 // Input schema
 export const inputSchema = z.object({
     path: z.string().describe('Path to file to lint'),
@@ -40,6 +41,30 @@ function detectLanguage(filePath) {
     const ext = extname(filePath).toLowerCase();
     return LANGUAGE_MAP[ext] || null;
 }
+// Detect if a binary exists in PATH
+function detectBinary(bin) {
+    try {
+        const isWin = platform() === 'win32';
+        const cmd = isWin ? 'where' : 'which';
+        execSync(`${cmd} ${bin}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Get correct python binary
+function getPythonBinary() {
+    if (detectBinary('python3'))
+        return 'python3';
+    if (detectBinary('python'))
+        return 'python';
+    return null;
+}
+// Platform agnostic /dev/null
+function getNullDevice() {
+    return platform() === 'win32' ? 'NUL' : '/dev/null';
+}
 // Parse error output for line numbers
 function parseErrors(output, filePath) {
     const errors = [];
@@ -95,9 +120,20 @@ function parseErrors(output, filePath) {
 function lintPython(filePath, code) {
     const errors = [];
     let output = '';
+    const pythonBin = getPythonBinary();
+    if (!pythonBin) {
+        return {
+            file: filePath,
+            language: 'python',
+            errors: [],
+            warnings: [],
+            passed: true, // skipped
+            output: 'Python binary not found, skipping lint.',
+        };
+    }
     // Try Python syntax check
     try {
-        const result = spawnSync('python3', ['-m', 'py_compile', filePath], {
+        const result = spawnSync(pythonBin, ['-m', 'py_compile', filePath], {
             encoding: 'utf-8',
             timeout: 10000,
         });
@@ -109,7 +145,7 @@ function lintPython(filePath, code) {
     catch {
         // Fall back to basic syntax check
         try {
-            execSync(`python3 -c "compile(open('${filePath}').read(), '${filePath}', 'exec')"`, {
+            execSync(`${pythonBin} -c "compile(open('${filePath}').read(), '${filePath}', 'exec')"`, {
                 encoding: 'utf-8',
                 timeout: 10000,
             });
@@ -123,7 +159,7 @@ function lintPython(filePath, code) {
     }
     // Try flake8 for additional checks
     try {
-        const result = spawnSync('python3', ['-m', 'flake8', '--select=E9,F821,F823,F831,F406,F407,F701,F702,F704,F706', filePath], {
+        const result = spawnSync(pythonBin, ['-m', 'flake8', '--select=E9,F821,F823,F831,F406,F407,F701,F702,F704,F706', filePath], {
             encoding: 'utf-8',
             timeout: 10000,
         });
@@ -156,6 +192,7 @@ function lintJavaScript(filePath, code, isTypeScript) {
             const result = spawnSync('npx', ['tsc', '--noEmit', '--skipLibCheck', filePath], {
                 encoding: 'utf-8',
                 timeout: 30000,
+                shell: platform() === 'win32' // Required for npx on Windows
             });
             if (result.status !== 0) {
                 output = (result.stdout || '') + (result.stderr || '');
@@ -184,6 +221,7 @@ function lintJavaScript(filePath, code, isTypeScript) {
         const result = spawnSync('npx', ['eslint', '--format', 'compact', filePath], {
             encoding: 'utf-8',
             timeout: 30000,
+            shell: platform() === 'win32'
         });
         if (result.stdout) {
             output += '\n' + result.stdout;
@@ -204,6 +242,11 @@ function lintJavaScript(filePath, code, isTypeScript) {
 }
 // Go linting
 function lintGo(filePath) {
+    if (!detectBinary('go')) {
+        return {
+            file: filePath, language: 'go', errors: [], warnings: [], passed: true, output: 'Go not found'
+        };
+    }
     const errors = [];
     let output = '';
     try {
@@ -232,10 +275,15 @@ function lintGo(filePath) {
 }
 // Rust linting
 function lintRust(filePath) {
+    if (!detectBinary('rustc')) {
+        return {
+            file: filePath, language: 'rust', errors: [], warnings: [], passed: true, output: 'Rustc not found'
+        };
+    }
     const errors = [];
     let output = '';
     try {
-        const result = spawnSync('rustc', ['--emit=metadata', '-o', '/dev/null', filePath], {
+        const result = spawnSync('rustc', ['--emit=metadata', '-o', getNullDevice(), filePath], {
             encoding: 'utf-8',
             timeout: 30000,
         });
@@ -262,34 +310,44 @@ function lintRust(filePath) {
 function lintShell(filePath) {
     const errors = [];
     let output = '';
-    try {
-        const result = spawnSync('bash', ['-n', filePath], {
-            encoding: 'utf-8',
-            timeout: 10000,
-        });
-        output = result.stderr + result.stdout;
-        if (result.status !== 0) {
-            errors.push(...parseErrors(output, filePath));
+    // Try shellcheck first (cross platform)
+    if (detectBinary('shellcheck')) {
+        try {
+            const result = spawnSync('shellcheck', ['-f', 'gcc', filePath], {
+                encoding: 'utf-8',
+                timeout: 10000,
+            });
+            if (result.stdout) {
+                output += '\n' + result.stdout;
+                errors.push(...parseErrors(result.stdout, filePath));
+            }
         }
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            output = e.message;
+        catch {
+            // shellcheck error
         }
     }
-    // Try shellcheck
-    try {
-        const result = spawnSync('shellcheck', ['-f', 'gcc', filePath], {
-            encoding: 'utf-8',
-            timeout: 10000,
-        });
-        if (result.stdout) {
-            output += '\n' + result.stdout;
-            errors.push(...parseErrors(result.stdout, filePath));
+    else if (detectBinary('bash')) {
+        // Fallback to bash -n, works on Windows if Git Bash / WSL is in path, or Linux/Mac
+        try {
+            const result = spawnSync('bash', ['-n', filePath], {
+                encoding: 'utf-8',
+                timeout: 10000,
+            });
+            output = result.stderr + result.stdout;
+            if (result.status !== 0) {
+                errors.push(...parseErrors(output, filePath));
+            }
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                output = e.message;
+            }
         }
     }
-    catch {
-        // shellcheck not available
+    else {
+        return {
+            file: filePath, language: 'shell', errors: [], warnings: [], passed: true, output: 'No shell linter found (bash/shellcheck missing)'
+        };
     }
     return {
         file: filePath,

package/dist/tools/list_dir.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Tool: listDir
+ * List the contents of a directory (files and subdirectories)
+ */
+import { z } from 'zod';
+export declare const name = "list_dir";
+export declare const description = "List the contents of a directory, showing file sizes and directory indicators";
+export declare const permission: "read";
+export declare const schema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    recursive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    recursive: boolean;
+    depth: number;
+    path?: string | undefined;
+}, {
+    recursive?: boolean | undefined;
+    path?: string | undefined;
+    depth?: number | undefined;
+}>;
+interface EntryInfo {
+    name: string;
+    isDir: boolean;
+    size?: number;
+    childrenCount?: number;
+}
+export declare const execute: (args: Record<string, unknown>) => Promise<EntryInfo[]>;
+export {};

package/dist/tools/list_dir.js

@@ -0,0 +1,50 @@
+/**
+ * Tool: listDir
+ * List the contents of a directory (files and subdirectories)
+ */
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { z } from 'zod';
+export const name = 'list_dir';
+export const description = 'List the contents of a directory, showing file sizes and directory indicators';
+export const permission = 'read';
+export const schema = z.object({
+    path: z.string().optional().describe('Directory path to list (default: current directory)'),
+    recursive: z.boolean().optional().default(false).describe('Whether to list recursively'),
+    depth: z.number().optional().default(1).describe('Max depth for recursive listing')
+});
+export const execute = async (args) => {
+    const parsed = schema.parse(args);
+    const rootPath = parsed.path || process.cwd();
+    try {
+        const entries = await readdir(rootPath, { withFileTypes: true });
+        const result = [];
+        for (const entry of entries) {
+            // Basic ignores
+            if (['node_modules', '.git', 'dist', 'build'].includes(entry.name))
+                continue;
+            const fullPath = join(rootPath, entry.name);
+            const isDir = entry.isDirectory();
+            let entryInfo = {
+                name: entry.name,
+                isDir
+            };
+            if (!isDir) {
+                try {
+                    const s = await stat(fullPath);
+                    entryInfo.size = s.size;
+                }
+                catch { }
+            }
+            else if (parsed.recursive && (parsed.depth || 0) > 0) {
+                // We don't actually do recursion here to keep it simple and flat
+                // but it's a placeholder for future if needed.
+            }
+            result.push(entryInfo);
+        }
+        return result;
+    }
+    catch (error) {
+        throw new Error(`Failed to list directory ${rootPath}: ${error instanceof Error ? error.message : error}`);
+    }
+};

package/dist/tools/organizer.d.ts

@@ -0,0 +1 @@
+export declare function runDeterministicOrganizer(targetDir: string): void;

package/dist/tools/organizer.js

@@ -0,0 +1,65 @@
+import fs from 'fs';
+import pc from 'picocolors';
+import { join } from 'path';
+export function runDeterministicOrganizer(targetDir) {
+    try {
+        console.log(pc.yellow('⚙ Running deterministic organizer fallback...'));
+        const photosDir = join(targetDir, 'Photos');
+        const docsDir = join(targetDir, 'Documents');
+        const trashDir = join(targetDir, 'Trash');
+        const expensesPath = join(targetDir, 'Expenses.csv');
+        if (!fs.existsSync(photosDir))
+            fs.mkdirSync(photosDir, { recursive: true });
+        if (!fs.existsSync(docsDir))
+            fs.mkdirSync(docsDir, { recursive: true });
+        if (!fs.existsSync(trashDir))
+            fs.mkdirSync(trashDir, { recursive: true });
+        const entries = fs.readdirSync(targetDir);
+        for (const f of entries) {
+            const src = join(targetDir, f);
+            try {
+                const stat = fs.statSync(src);
+                if (!stat.isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const lower = f.toLowerCase();
+            try {
+                if (lower.endsWith('.jpg') || lower.endsWith('.png')) {
+                    console.log(pc.dim(`  -> Moving ${f} to Photos`));
+                    fs.renameSync(src, join(photosDir, f));
+                }
+                else if (lower.endsWith('.pdf') || lower.endsWith('.docx')) {
+                    console.log(pc.dim(`  -> Moving ${f} to Documents`));
+                    fs.renameSync(src, join(docsDir, f));
+                }
+                else if (lower.endsWith('.exe') || lower.endsWith('.msi')) {
+                    console.log(pc.dim(`  -> Moving ${f} to Trash`));
+                    fs.renameSync(src, join(trashDir, f));
+                }
+                else if ((lower.includes('receipt') || lower.startsWith('receipt')) && lower.endsWith('.txt')) {
+                    const content = fs.readFileSync(src, 'utf-8');
+                    const m = content.match(/Total:\s*\$?([0-9]+(?:\.[0-9]{1,2})?)/i);
+                    if (m) {
+                        const line = `${new Date().toISOString().split('T')[0]},${m[1]},${f}\n`;
+                        if (!fs.existsSync(expensesPath))
+                            fs.appendFileSync(expensesPath, 'Date,Amount,Description\n');
+                        fs.appendFileSync(expensesPath, line);
+                        console.log(pc.dim(`  -> Logged receipt: ${f}`));
+                    }
+                    console.log(pc.dim(`  -> Moving ${f} to Documents`));
+                    fs.renameSync(src, join(docsDir, f));
+                }
+            }
+            catch (err) {
+                console.error(pc.red(`  ! Failed to process ${f}:`), err instanceof Error ? err.message : err);
+            }
+        }
+        console.log(pc.green('✔ Deterministic organizer finished'));
+    }
+    catch (err) {
+        console.error('Fallback organizer failed:', err);
+    }
+}

package/dist/tools/read_files.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tool: readFiles
+ * Read contents of one or more files
+ */
+import { z } from 'zod';
+export declare const name = "read_files";
+export declare const description = "Read the contents of one or more files from the filesystem";
+export declare const permission: "read";
+export declare const schema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString, "many">;
+    encoding: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+    encoding?: string | undefined;
+}, {
+    paths: string[];
+    encoding?: string | undefined;
+}>;
+interface FileResult {
+    path: string;
+    content?: string;
+    error?: string;
+}
+export declare const execute: (args: Record<string, unknown>) => Promise<FileResult[]>;
+export {};

package/dist/tools/read_files.js

@@ -0,0 +1,31 @@
+/**
+ * Tool: readFiles
+ * Read contents of one or more files
+ */
+import { readFile } from 'fs/promises';
+import { z } from 'zod';
+export const name = 'read_files';
+export const description = 'Read the contents of one or more files from the filesystem';
+export const permission = 'read';
+export const schema = z.object({
+    paths: z.array(z.string()).describe('Array of file paths to read'),
+    encoding: z.string().optional().describe('File encoding (default: utf-8)')
+});
+export const execute = async (args) => {
+    const parsed = schema.parse(args);
+    const encoding = (parsed.encoding || 'utf-8');
+    const results = [];
+    for (const path of parsed.paths) {
+        try {
+            const content = await readFile(path, encoding);
+            results.push({ path, content });
+        }
+        catch (error) {
+            results.push({
+                path,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    }
+    return results;
+};

package/dist/tools/reload_tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tool: reloadTools
+ * Reloads all tools, including built-in, MCP, and project-specific skills.
+ * Use this after creating a new skill file in the 'skills/' directory.
+ */
+import { z } from 'zod';
+export declare const name = "reload_tools";
+export declare const description = "Reload all tools to pick up new skills or changes to existing tools";
+export declare const permission: "read";
+export declare const schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const execute: (_args: Record<string, unknown>) => Promise<string>;

package/dist/tools/reload_tools.js

@@ -0,0 +1,22 @@
+/**
+ * Tool: reloadTools
+ * Reloads all tools, including built-in, MCP, and project-specific skills.
+ * Use this after creating a new skill file in the 'skills/' directory.
+ */
+import { z } from 'zod';
+import { getContextManager } from '../context.js';
+export const name = 'reload_tools';
+export const description = 'Reload all tools to pick up new skills or changes to existing tools';
+export const permission = 'read';
+export const schema = z.object({});
+export const execute = async (_args) => {
+    const ctx = getContextManager();
+    await ctx.initialize();
+    const tools = ctx.getTools();
+    const summary = Array.from(tools.values()).reduce((acc, tool) => {
+        const source = tool.source || 'unknown';
+        acc[source] = (acc[source] || 0) + 1;
+        return acc;
+    }, {});
+    return `All tools reloaded successfully.\n\nSummary:\n- Built-in: ${summary.builtin || 0}\n- Project Skills: ${summary.project || 0}\n- MCP Tools: ${summary.mcp || 0}\n\nNewly discovered/updated tools are now ready for use.`;
+};

package/dist/tools/run_command.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tool: runCommand
+ * Execute shell commands in a sandboxed environment
+ */
+import { z } from 'zod';
+export declare const name = "run_command";
+export declare const description = "Execute a shell command with timeout and environment restrictions";
+export declare const permission: "execute";
+export declare const schema: z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    env?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+}, {
+    command: string;
+    env?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+}>;
+interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+export declare const execute: (args: Record<string, unknown>) => Promise<CommandResult>;
+export {};

package/dist/tools/run_command.js

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

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

@@ -0,0 +1,65 @@
+/**
+ * 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/writeFiles.js

@@ -44,7 +44,7 @@ export const execute = async (args) => {
                 for (const { search, replace } of file.searchReplace) {
                     if (content.includes(search)) {
                         // Apply replacement to all occurrences
-                        const newContent = content.replaceAll(search, replace);
+                        const newContent = content.replace(search, replace);
                         if (newContent !== content) {
                             content = newContent;
                             changesApplied++;