ralph-cli-sandboxed 0.2.6 → 0.2.8

package/dist/commands/once.js

@@ -1,6 +1,10 @@
 import { spawn } from "child_process";
+import { existsSync, appendFileSync, mkdirSync } from "fs";
+import { join } from "path";
 import { checkFilesExist, loadConfig, loadPrompt, getPaths, getCliConfig, requireContainer } from "../utils/config.js";
-import { resolvePromptVariables } from "../templates/prompts.js";
+import { resolvePromptVariables, getCliProviders } from "../templates/prompts.js";
+import { getStreamJsonParser } from "../utils/stream-json.js";
+import { sendNotification } from "../utils/notification.js";
 export async function once(args) {
     // Parse flags
     let debug = false;
@@ -32,16 +36,62 @@ export async function once(args) {
     });
     const paths = getPaths();
     const cliConfig = getCliConfig(config);
-    console.log("Starting single ralph iteration...\n");
+    // Check if stream-json output is enabled
+    const streamJsonConfig = config.docker?.asciinema?.streamJson;
+    const streamJsonEnabled = streamJsonConfig?.enabled ?? false;
+    const saveRawJson = streamJsonConfig?.saveRawJson !== false; // default true
+    const outputDir = config.docker?.asciinema?.outputDir || ".recordings";
+    // Get provider-specific streamJsonArgs (empty array if not defined)
+    // This allows providers without JSON streaming to still have output displayed
+    const providers = getCliProviders();
+    const providerConfig = config.cliProvider ? providers[config.cliProvider] : providers["claude"];
+    const streamJsonArgs = providerConfig?.streamJsonArgs ?? [];
+    console.log("Starting single ralph iteration...");
+    if (streamJsonEnabled) {
+        console.log("Stream JSON output enabled - displaying formatted Claude output");
+        if (saveRawJson) {
+            console.log(`Raw JSON logs will be saved to: ${outputDir}/`);
+        }
+    }
+    console.log();
     // Build CLI arguments: config args + yolo args + model args + prompt args
     // Use yoloArgs from config if available, otherwise default to Claude's --dangerously-skip-permissions
     const yoloArgs = cliConfig.yoloArgs ?? ["--dangerously-skip-permissions"];
     const promptArgs = cliConfig.promptArgs ?? ["-p"];
-    const promptValue = `@${paths.prd} @${paths.progress} ${prompt}`;
     const cliArgs = [
         ...(cliConfig.args ?? []),
         ...yoloArgs,
     ];
+    // Build the prompt value based on whether fileArgs is configured
+    // fileArgs (e.g., ["--read"] for Aider) means files are passed as separate arguments
+    // Otherwise, use @file syntax embedded in the prompt (Claude Code style)
+    let promptValue;
+    if (cliConfig.fileArgs && cliConfig.fileArgs.length > 0) {
+        // Add files as separate arguments (e.g., --read prd.json --read progress.txt)
+        for (const fileArg of cliConfig.fileArgs) {
+            cliArgs.push(fileArg, paths.prd);
+            cliArgs.push(fileArg, paths.progress);
+        }
+        promptValue = prompt;
+    }
+    else {
+        // Use @file syntax embedded in the prompt
+        promptValue = `@${paths.prd} @${paths.progress} ${prompt}`;
+    }
+    // Add stream-json output format if enabled (using provider-specific args)
+    let jsonLogPath;
+    if (streamJsonEnabled) {
+        cliArgs.push(...streamJsonArgs);
+        // Setup JSON log file if saving raw JSON
+        if (saveRawJson) {
+            const fullOutputDir = join(process.cwd(), outputDir);
+            if (!existsSync(fullOutputDir)) {
+                mkdirSync(fullOutputDir, { recursive: true });
+            }
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+            jsonLogPath = join(fullOutputDir, `ralph-once-${timestamp}.jsonl`);
+        }
+    }
     // Add model args if model is specified
     if (model && cliConfig.modelArgs) {
         cliArgs.push(...cliConfig.modelArgs, model);
@@ -49,19 +99,128 @@ export async function once(args) {
     cliArgs.push(...promptArgs, promptValue);
     if (debug) {
         console.log(`[debug] ${cliConfig.command} ${cliArgs.map(a => a.includes(" ") ? `"${a}"` : a).join(" ")}\n`);
+        if (jsonLogPath) {
+            console.log(`[debug] Saving raw JSON to: ${jsonLogPath}\n`);
+        }
     }
+    // Create provider-specific stream-json parser
+    const streamJsonParser = getStreamJsonParser(config.cliProvider, debug);
+    // Notification options for this run
+    const notifyOptions = { command: config.notifyCommand, debug };
     return new Promise((resolve, reject) => {
-        const proc = spawn(cliConfig.command, cliArgs, {
-            stdio: "inherit",
-        });
-        proc.on("close", (code) => {
-            if (code !== 0) {
-                console.error(`\n${cliConfig.command} exited with code ${code}`);
-            }
-            resolve();
-        });
-        proc.on("error", (err) => {
-            reject(new Error(`Failed to start ${cliConfig.command}: ${err.message}`));
-        });
+        let output = ""; // Accumulate output for PRD complete detection
+        if (streamJsonEnabled) {
+            // Stream JSON mode: capture stdout, parse JSON, display clean text
+            let lineBuffer = "";
+            const proc = spawn(cliConfig.command, cliArgs, {
+                stdio: ["inherit", "pipe", "inherit"],
+            });
+            proc.stdout.on("data", (data) => {
+                const chunk = data.toString();
+                lineBuffer += chunk;
+                const lines = lineBuffer.split("\n");
+                // Keep the last incomplete line in the buffer
+                lineBuffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine)
+                        continue;
+                    // Check if this is a JSON line
+                    if (trimmedLine.startsWith("{")) {
+                        // Save raw JSON if enabled
+                        if (jsonLogPath) {
+                            try {
+                                appendFileSync(jsonLogPath, trimmedLine + "\n");
+                            }
+                            catch {
+                                // Ignore write errors
+                            }
+                        }
+                        // Parse and display clean text using provider-specific parser
+                        const text = streamJsonParser.parseStreamJsonLine(trimmedLine);
+                        if (text) {
+                            process.stdout.write(text);
+                            output += text; // Accumulate for completion detection
+                        }
+                    }
+                    else {
+                        // Non-JSON line - display as-is (might be status messages, errors, etc.)
+                        process.stdout.write(trimmedLine + "\n");
+                        output += trimmedLine + "\n";
+                    }
+                }
+            });
+            proc.on("close", async (code) => {
+                // Process any remaining buffered content
+                if (lineBuffer.trim()) {
+                    const trimmedLine = lineBuffer.trim();
+                    if (trimmedLine.startsWith("{")) {
+                        if (jsonLogPath) {
+                            try {
+                                appendFileSync(jsonLogPath, trimmedLine + "\n");
+                            }
+                            catch {
+                                // Ignore write errors
+                            }
+                        }
+                        const text = streamJsonParser.parseStreamJsonLine(trimmedLine);
+                        if (text) {
+                            process.stdout.write(text);
+                            output += text;
+                        }
+                    }
+                    else {
+                        // Non-JSON remaining content
+                        process.stdout.write(trimmedLine + "\n");
+                        output += trimmedLine + "\n";
+                    }
+                }
+                // Ensure final newline
+                process.stdout.write("\n");
+                // Send notification based on outcome
+                if (code !== 0) {
+                    console.error(`\n${cliConfig.command} exited with code ${code}`);
+                    await sendNotification("error", `Ralph: Iteration failed with exit code ${code}`, notifyOptions);
+                }
+                else if (output.includes("<promise>COMPLETE</promise>")) {
+                    await sendNotification("prd_complete", undefined, notifyOptions);
+                }
+                else {
+                    await sendNotification("iteration_complete", undefined, notifyOptions);
+                }
+                resolve();
+            });
+            proc.on("error", (err) => {
+                reject(new Error(`Failed to start ${cliConfig.command}: ${err.message}`));
+            });
+        }
+        else {
+            // Standard mode: capture stdout while passing through
+            const proc = spawn(cliConfig.command, cliArgs, {
+                stdio: ["inherit", "pipe", "inherit"],
+            });
+            proc.stdout.on("data", (data) => {
+                const chunk = data.toString();
+                output += chunk;
+                process.stdout.write(chunk);
+            });
+            proc.on("close", async (code) => {
+                // Send notification based on outcome
+                if (code !== 0) {
+                    console.error(`\n${cliConfig.command} exited with code ${code}`);
+                    await sendNotification("error", `Ralph: Iteration failed with exit code ${code}`, notifyOptions);
+                }
+                else if (output.includes("<promise>COMPLETE</promise>")) {
+                    await sendNotification("prd_complete", undefined, notifyOptions);
+                }
+                else {
+                    await sendNotification("iteration_complete", undefined, notifyOptions);
+                }
+                resolve();
+            });
+            proc.on("error", (err) => {
+                reject(new Error(`Failed to start ${cliConfig.command}: ${err.message}`));
+            });
+        }
     });
 }

package/dist/commands/run.js

@@ -1,9 +1,11 @@
 import { spawn } from "child_process";
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, appendFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { checkFilesExist, loadConfig, loadPrompt, getPaths, getCliConfig, requireContainer } from "../utils/config.js";
-import { resolvePromptVariables } from "../templates/prompts.js";
+import { resolvePromptVariables, getCliProviders } from "../templates/prompts.js";
 import { validatePrd, smartMerge, readPrdFile, writePrd, expandPrdFileReferences } from "../utils/prd-validator.js";
+import { getStreamJsonParser } from "../utils/stream-json.js";
+import { sendNotification } from "../utils/notification.js";
 const CATEGORIES = ["ui", "feature", "bugfix", "setup", "development", "testing", "docs"];
 /**
  * Creates a filtered PRD file containing only incomplete items (passes: false).
@@ -13,7 +15,23 @@ const CATEGORIES = ["ui", "feature", "bugfix", "setup", "development", "testing"
  */
 function createFilteredPrd(prdPath, baseDir, category) {
     const content = readFileSync(prdPath, "utf-8");
-    const items = JSON.parse(content);
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        console.error("\x1b[31mError: prd.json contains invalid JSON.\x1b[0m");
+        console.error("The file may have been corrupted by an LLM.\n");
+        console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
+        process.exit(1);
+    }
+    if (!Array.isArray(parsed)) {
+        console.error("\x1b[31mError: prd.json is corrupted - expected an array of items.\x1b[0m");
+        console.error("The file may have been modified incorrectly by an LLM.\n");
+        console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
+        process.exit(1);
+    }
+    const items = parsed;
     let filteredItems = items.filter(item => item.passes === false);
     // Apply category filter if specified
     if (category) {
@@ -42,9 +60,20 @@ function syncPassesFromTasks(tasksPath, prdPath) {
     }
     try {
         const tasksContent = readFileSync(tasksPath, "utf-8");
-        const tasks = JSON.parse(tasksContent);
+        const tasksParsed = JSON.parse(tasksContent);
+        if (!Array.isArray(tasksParsed)) {
+            console.warn("\x1b[33mWarning: prd-tasks.json is not a valid array - skipping sync.\x1b[0m");
+            return 0;
+        }
+        const tasks = tasksParsed;
         const prdContent = readFileSync(prdPath, "utf-8");
-        const prd = JSON.parse(prdContent);
+        const prdParsed = JSON.parse(prdContent);
+        if (!Array.isArray(prdParsed)) {
+            console.warn("\x1b[33mWarning: prd.json is corrupted - skipping sync.\x1b[0m");
+            console.warn("Run \x1b[36mralph fix-prd\x1b[0m after this session to repair.\n");
+            return 0;
+        }
+        const prd = prdParsed;
         let synced = 0;
         // Find tasks that were marked as passing
         for (const task of tasks) {
@@ -71,9 +100,11 @@ function syncPassesFromTasks(tasksPath, prdPath) {
         return 0;
     }
 }
-async function runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig, debug, model) {
+async function runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig, debug, model, streamJson) {
     return new Promise((resolve, reject) => {
         let output = "";
+        let jsonLogPath;
+        let lineBuffer = ""; // Buffer for incomplete JSON lines
         // Build CLI arguments: config args + yolo args + model args + prompt args
         const cliArgs = [
             ...(cliConfig.args ?? []),
@@ -84,6 +115,19 @@ async function runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig
             const yoloArgs = cliConfig.yoloArgs ?? ["--dangerously-skip-permissions"];
             cliArgs.push(...yoloArgs);
         }
+        // Add stream-json output format if enabled (using provider-specific args)
+        if (streamJson?.enabled) {
+            cliArgs.push(...streamJson.args);
+            // Setup JSON log file if saving raw JSON
+            if (streamJson.saveRawJson) {
+                const outputDir = join(process.cwd(), streamJson.outputDir);
+                if (!existsSync(outputDir)) {
+                    mkdirSync(outputDir, { recursive: true });
+                }
+                const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+                jsonLogPath = join(outputDir, `ralph-run-${timestamp}.jsonl`);
+            }
+        }
         // Add model args if model is specified
         if (model && cliConfig.modelArgs) {
             cliArgs.push(...cliConfig.modelArgs, model);
@@ -91,20 +135,104 @@ async function runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig
         // Use the filtered PRD (only incomplete items) for the prompt
         // promptArgs specifies flags to use (e.g., ["-p"] for Claude, [] for positional)
         const promptArgs = cliConfig.promptArgs ?? ["-p"];
-        const promptValue = `@${filteredPrdPath} @${paths.progress} ${prompt}`;
+        // Build the prompt value based on whether fileArgs is configured
+        // fileArgs (e.g., ["--read"] for Aider) means files are passed as separate arguments
+        // Otherwise, use @file syntax embedded in the prompt (Claude Code style)
+        let promptValue;
+        if (cliConfig.fileArgs && cliConfig.fileArgs.length > 0) {
+            // Add files as separate arguments (e.g., --read prd-tasks.json --read progress.txt)
+            for (const fileArg of cliConfig.fileArgs) {
+                cliArgs.push(fileArg, filteredPrdPath);
+                cliArgs.push(fileArg, paths.progress);
+            }
+            promptValue = prompt;
+        }
+        else {
+            // Use @file syntax embedded in the prompt
+            promptValue = `@${filteredPrdPath} @${paths.progress} ${prompt}`;
+        }
         cliArgs.push(...promptArgs, promptValue);
         if (debug) {
             console.log(`[debug] ${cliConfig.command} ${cliArgs.map(a => a.includes(" ") ? `"${a}"` : a).join(" ")}\n`);
+            if (jsonLogPath) {
+                console.log(`[debug] Saving raw JSON to: ${jsonLogPath}\n`);
+            }
         }
         const proc = spawn(cliConfig.command, cliArgs, {
             stdio: ["inherit", "pipe", "inherit"],
         });
         proc.stdout.on("data", (data) => {
             const chunk = data.toString();
-            output += chunk;
-            process.stdout.write(chunk);
+            if (streamJson?.enabled) {
+                // Process stream-json output: parse JSON and display clean text
+                lineBuffer += chunk;
+                const lines = lineBuffer.split("\n");
+                // Keep the last incomplete line in the buffer
+                lineBuffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine)
+                        continue;
+                    // Check if this is a JSON line
+                    if (trimmedLine.startsWith("{")) {
+                        // Save raw JSON if enabled
+                        if (jsonLogPath) {
+                            try {
+                                appendFileSync(jsonLogPath, trimmedLine + "\n");
+                            }
+                            catch {
+                                // Ignore write errors
+                            }
+                        }
+                        // Parse and display clean text using provider-specific parser
+                        const text = streamJson.parser.parseStreamJsonLine(trimmedLine);
+                        if (text) {
+                            process.stdout.write(text);
+                            output += text; // Accumulate parsed text for completion detection
+                        }
+                    }
+                    else {
+                        // Non-JSON line - display as-is (might be status messages, errors, etc.)
+                        process.stdout.write(trimmedLine + "\n");
+                        output += trimmedLine + "\n";
+                    }
+                }
+            }
+            else {
+                // Standard output: pass through as-is
+                output += chunk;
+                process.stdout.write(chunk);
+            }
         });
         proc.on("close", (code) => {
+            // Process any remaining buffered content
+            if (streamJson?.enabled && lineBuffer.trim()) {
+                const trimmedLine = lineBuffer.trim();
+                if (trimmedLine.startsWith("{")) {
+                    if (jsonLogPath) {
+                        try {
+                            appendFileSync(jsonLogPath, trimmedLine + "\n");
+                        }
+                        catch {
+                            // Ignore write errors
+                        }
+                    }
+                    const text = streamJson.parser.parseStreamJsonLine(trimmedLine);
+                    if (text) {
+                        process.stdout.write(text);
+                        output += text;
+                    }
+                }
+                else {
+                    // Non-JSON remaining content
+                    process.stdout.write(trimmedLine + "\n");
+                    output += trimmedLine + "\n";
+                }
+            }
+            // Ensure final newline for clean output
+            if (streamJson?.enabled) {
+                process.stdout.write("\n");
+            }
             resolve({ exitCode: code ?? 0, output });
         });
         proc.on("error", (err) => {
@@ -142,7 +270,23 @@ function formatElapsedTime(startTime, endTime) {
  */
 function countPrdItems(prdPath, category) {
     const content = readFileSync(prdPath, "utf-8");
-    const items = JSON.parse(content);
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        console.error("\x1b[31mError: prd.json contains invalid JSON.\x1b[0m");
+        console.error("The file may have been corrupted by an LLM.\n");
+        console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
+        process.exit(1);
+    }
+    if (!Array.isArray(parsed)) {
+        console.error("\x1b[31mError: prd.json is corrupted - expected an array of items.\x1b[0m");
+        console.error("The file may have been modified incorrectly by an LLM.\n");
+        console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
+        process.exit(1);
+    }
+    const items = parsed;
     let filteredItems = items;
     if (category) {
         filteredItems = items.filter(item => item.category === category);
@@ -265,6 +409,21 @@ export async function run(args) {
     });
     const paths = getPaths();
     const cliConfig = getCliConfig(config);
+    // Check if stream-json output is enabled
+    const streamJsonConfig = config.docker?.asciinema?.streamJson;
+    // Get provider-specific streamJsonArgs, falling back to Claude's defaults
+    const providers = getCliProviders();
+    const providerConfig = config.cliProvider ? providers[config.cliProvider] : providers["claude"];
+    // Only use provider's streamJsonArgs if defined, otherwise empty array (no special args)
+    // This allows providers without JSON streaming to still have output displayed
+    const streamJsonArgs = providerConfig?.streamJsonArgs ?? [];
+    const streamJson = streamJsonConfig?.enabled ? {
+        enabled: true,
+        saveRawJson: streamJsonConfig.saveRawJson !== false, // default true
+        outputDir: config.docker?.asciinema?.outputDir || ".recordings",
+        args: streamJsonArgs,
+        parser: getStreamJsonParser(config.cliProvider, debug),
+    } : undefined;
     // Progress tracking: stop only if no tasks complete after N iterations
     const MAX_ITERATIONS_WITHOUT_PROGRESS = 3;
     // Get requested iteration count (may be adjusted dynamically)
@@ -285,6 +444,12 @@ export async function run(args) {
     if (category) {
         console.log(`Filtering PRD items by category: ${category}`);
     }
+    if (streamJson?.enabled) {
+        console.log("Stream JSON output enabled - displaying formatted Claude output");
+        if (streamJson.saveRawJson) {
+            console.log(`Raw JSON logs will be saved to: ${streamJson.outputDir}/`);
+        }
+    }
     console.log();
     // Track temp file for cleanup
     let filteredPrdPath = null;
@@ -378,10 +543,15 @@ export async function run(args) {
                         console.log("PRD COMPLETE - All features already implemented!");
                     }
                     console.log("=".repeat(50));
+                    // Send notification for PRD completion
+                    await sendNotification("prd_complete", undefined, {
+                        command: config.notifyCommand,
+                        debug,
+                    });
                     break;
                 }
             }
-            const { exitCode, output } = await runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig, debug, model);
+            const { exitCode, output } = await runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig, debug, model, streamJson);
             // Sync any completed items from prd-tasks.json back to prd.json
             // This catches cases where the LLM updated prd-tasks.json instead of prd.json
             syncPassesFromTasks(filteredPrdPath, paths.prd);
@@ -415,6 +585,8 @@ export async function run(args) {
                     console.log(`(No tasks completed and no new tasks added)`);
                     console.log(`Status: ${progressCounts.complete}/${progressCounts.total} complete, ${progressCounts.incomplete} remaining.`);
                     console.log("Check the PRD and task definitions for issues.");
+                    // Send notification about stopped run
+                    await sendNotification("run_stopped", `Ralph: Run stopped - no progress after ${MAX_ITERATIONS_WITHOUT_PROGRESS} iterations. ${progressCounts.incomplete} tasks remaining.`, { command: config.notifyCommand, debug });
                     break;
                 }
             }
@@ -432,6 +604,8 @@ export async function run(args) {
                     console.error(`\nStopping: ${cliConfig.command} failed ${consecutiveFailures} times in a row with exit code ${exitCode}.`);
                     console.error("This usually indicates a configuration error (e.g., missing API key).");
                     console.error("Please check your CLI configuration and try again.");
+                    // Send notification about error
+                    await sendNotification("error", `Ralph: CLI failed ${consecutiveFailures} times with exit code ${exitCode}. Check configuration.`, { command: config.notifyCommand, debug });
                     break;
                 }
                 console.log("Continuing to next iteration...");
@@ -472,13 +646,10 @@ export async function run(args) {
                     }
                     console.log("=".repeat(50));
                     // Send notification if configured
-                    if (config.notifyCommand) {
-                        const [cmd, ...cmdArgs] = config.notifyCommand.split(" ");
-                        const notifyProc = spawn(cmd, [...cmdArgs, "Ralph: PRD Complete!"], { stdio: "ignore" });
-                        notifyProc.on("error", () => {
-                            // Notification command not available, ignore
-                        });
-                    }
+                    await sendNotification("prd_complete", undefined, {
+                        command: config.notifyCommand,
+                        debug,
+                    });
                     break;
                 }
             }

package/dist/config/cli-providers.json

@@ -4,9 +4,10 @@
       "name": "Claude Code",
       "description": "Anthropic's Claude Code CLI",
       "command": "claude",
-      "defaultArgs": ["--permission-mode", "acceptEdits"],
+      "defaultArgs": [],
       "yoloArgs": ["--dangerously-skip-permissions"],
       "promptArgs": ["-p"],
+      "streamJsonArgs": ["--output-format", "stream-json", "--verbose", "--print"],
       "docker": {
         "install": "# Install Claude Code CLI (as node user so it installs to /home/node/.local/bin)\nRUN su - node -c 'curl -fsSL https://claude.ai/install.sh | bash' \\\n    && echo 'export PATH=\"$HOME/.local/bin:$PATH\"' >> /home/node/.zshrc"
       },
@@ -25,6 +26,7 @@
       "defaultArgs": ["--yes"],
       "yoloArgs": ["--yes-always"],
       "promptArgs": ["--message"],
+      "fileArgs": ["--read"],
       "docker": {
         "install": "# Install Aider (requires Python)\nRUN apt-get update && apt-get install -y python3 python3-pip && rm -rf /var/lib/apt/lists/* \\\n    && pip3 install --break-system-packages --no-cache-dir aider-chat",
         "note": "Check 'aider --help' for available flags"
@@ -43,7 +45,8 @@
       "command": "codex",
       "defaultArgs": ["--approval-mode", "suggest"],
       "yoloArgs": ["--approval-mode", "full-auto"],
-      "promptArgs": [],
+      "promptArgs": ["exec"],
+      "streamJsonArgs": ["--json"],
       "docker": {
         "install": "# Install OpenAI Codex CLI\nRUN npm install -g @openai/codex",
         "note": "Check 'codex --help' for available flags"
@@ -63,6 +66,7 @@
       "defaultArgs": [],
       "yoloArgs": ["-y"],
       "promptArgs": [],
+      "streamJsonArgs": ["--output-format", "json"],
       "docker": {
         "install": "# Install Google Gemini CLI\nRUN npm install -g @google/gemini-cli",
         "note": "Check 'gemini --help' for available flags"
@@ -80,8 +84,9 @@
       "description": "Open source AI coding agent for the terminal",
       "command": "opencode",
       "defaultArgs": [],
-      "yoloArgs": ["--yolo"],
+      "yoloArgs": [],
       "promptArgs": ["run"],
+      "streamJsonArgs": ["--format", "json"],
       "docker": {
         "install": "# Install OpenCode (as node user)\nRUN su - node -c 'curl -fsSL https://opencode.ai/install | bash' \\\n    && echo 'export PATH=\"$HOME/.opencode/bin:$PATH\"' >> /home/node/.zshrc",
         "note": "Check 'opencode --help' for available flags"
@@ -111,6 +116,26 @@
       },
       "modelArgs": ["--model"]
     },
+    "goose": {
+      "name": "Goose CLI",
+      "description": "Block's Goose AI coding agent",
+      "command": "goose",
+      "defaultArgs": [],
+      "yoloArgs": [],
+      "promptArgs": ["run", "--text"],
+      "streamJsonArgs": ["--output-format", "stream-json"],
+      "docker": {
+        "install": "# Install Goose CLI (requires Python)\nRUN apt-get update && apt-get install -y python3 python3-pip python3-venv && rm -rf /var/lib/apt/lists/* \\\n    && pip3 install --break-system-packages --no-cache-dir goose-ai",
+        "note": "Check 'goose --help' for available flags"
+      },
+      "envVars": ["OPENAI_API_KEY", "ANTHROPIC_API_KEY"],
+      "credentialMount": null,
+      "modelConfig": {
+        "envVar": "GOOSE_PROVIDER",
+        "note": "Set provider via GOOSE_PROVIDER env var"
+      },
+      "modelArgs": ["--model"]
+    },
     "custom": {
       "name": "Custom CLI",
       "description": "Configure your own AI CLI tool",

package/dist/config/skills.json

@@ -0,0 +1,12 @@
+{
+  "skills": {
+    "swift": [
+      {
+        "name": "swift-main-naming",
+        "description": "Prevents naming files main.swift when using @main attribute",
+        "instructions": "IMPORTANT: In Swift, files containing the @main attribute MUST NOT be named main.swift.\n\nWhen the @main attribute is used (e.g., @main struct App), Swift automatically generates an entry point. If the file is also named main.swift, Swift treats it as having a manual entry point, causing a conflict.\n\nRULES:\n- Never name a file main.swift if it contains @main attribute\n- Use descriptive names like App.swift, MyApp.swift, or the actual type name\n- If you encounter a main.swift with @main, rename it to match the type (e.g., struct MyApp -> MyApp.swift)\n\nEXAMPLES:\n\nBAD:\n```\n// main.swift\n@main\nstruct App {\n    static func main() { ... }\n}\n```\n\nGOOD:\n```\n// App.swift\n@main\nstruct App {\n    static func main() { ... }\n}\n```",
+        "userInvocable": false
+      }
+    ]
+  }
+}

package/dist/templates/prompts.d.ts

@@ -35,6 +35,8 @@ export interface CliProviderConfig {
     yoloArgs: string[];
     promptArgs: string[];
     modelArgs?: string[];
+    fileArgs?: string[];
+    streamJsonArgs?: string[];
     docker: {
         install: string;
     };
@@ -48,9 +50,20 @@ export interface CliProviderConfig {
 interface CliProvidersJson {
     providers: Record<string, CliProviderConfig>;
 }
+export interface SkillDefinition {
+    name: string;
+    description: string;
+    instructions: string;
+    userInvocable?: boolean;
+}
+interface SkillsJson {
+    skills: Record<string, SkillDefinition[]>;
+}
 export declare function getLanguagesJson(): LanguagesJson;
 export declare function getCliProvidersJson(): CliProvidersJson;
 export declare function getCliProviders(): Record<string, CliProviderConfig>;
+export declare function getSkillsJson(): SkillsJson;
+export declare function getSkillsForLanguage(language: string): SkillDefinition[];
 export declare function getLanguages(): Record<string, LanguageConfig>;
 export declare const LANGUAGES: Record<string, LanguageConfig>;
 export declare function generatePromptTemplate(): string;