ralph-cli-sandboxed 0.2.5 → 0.2.7

package/dist/commands/init.js

@@ -1,7 +1,7 @@
 import { existsSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
 import { join, basename, dirname } from "path";
 import { fileURLToPath } from "url";
-import { getLanguages, generatePromptTemplate, DEFAULT_PRD, DEFAULT_PROGRESS, getCliProviders } from "../templates/prompts.js";
+import { getLanguages, generatePromptTemplate, DEFAULT_PRD, DEFAULT_PROGRESS, getCliProviders, getSkillsForLanguage } from "../templates/prompts.js";
 import { promptSelectWithArrows, promptConfirm, promptInput, promptMultiSelectWithArrows } from "../utils/prompt.js";
 import { dockerInit } from "./docker.js";
 // Get package root directory (works for both dev and installed package)
@@ -14,118 +14,202 @@ const PROMPT_FILE = "prompt.md";
 const PRD_FILE = "prd.json";
 const PROGRESS_FILE = "progress.txt";
 const PRD_GUIDE_FILE = "HOW-TO-WRITE-PRDs.md";
-export async function init(_args) {
+export async function init(args) {
     const cwd = process.cwd();
     const ralphDir = join(cwd, RALPH_DIR);
+    const useDefaults = args.includes("-y") || args.includes("--yes");
     console.log("Initializing ralph in current directory...\n");
     // Check for existing .ralph directory
     if (existsSync(ralphDir)) {
-        const reinit = await promptConfirm(".ralph/ directory already exists. Re-initialize?");
-        if (!reinit) {
-            console.log("Aborted.");
-            return;
+        if (!useDefaults) {
+            const reinit = await promptConfirm(".ralph/ directory already exists. Re-initialize?");
+            if (!reinit) {
+                console.log("Aborted.");
+                return;
+            }
         }
     }
     else {
         mkdirSync(ralphDir, { recursive: true });
         console.log(`Created ${RALPH_DIR}/`);
     }
-    // Step 1: Select CLI provider (first)
     const CLI_PROVIDERS = getCliProviders();
-    const providerKeys = Object.keys(CLI_PROVIDERS);
-    const providerNames = providerKeys.map(k => `${CLI_PROVIDERS[k].name} - ${CLI_PROVIDERS[k].description}`);
-    const selectedProviderName = await promptSelectWithArrows("Select your AI CLI provider:", providerNames);
-    const selectedProviderIndex = providerNames.indexOf(selectedProviderName);
-    const selectedCliProviderKey = providerKeys[selectedProviderIndex];
-    const selectedProvider = CLI_PROVIDERS[selectedCliProviderKey];
+    const LANGUAGES = getLanguages();
+    let selectedCliProviderKey;
     let cliConfig;
-    // Handle custom CLI provider
-    if (selectedCliProviderKey === "custom") {
-        const customCommand = await promptInput("\nEnter your CLI command: ");
-        const customArgsInput = await promptInput("Enter default arguments (space-separated): ");
-        const customArgs = customArgsInput.trim() ? customArgsInput.trim().split(/\s+/) : [];
-        const customYoloArgsInput = await promptInput("Enter yolo/auto-approve arguments (space-separated): ");
-        const customYoloArgs = customYoloArgsInput.trim() ? customYoloArgsInput.trim().split(/\s+/) : [];
-        const customPromptArgsInput = await promptInput("Enter prompt arguments (e.g., -p for flag-based, leave empty for positional): ");
-        const customPromptArgs = customPromptArgsInput.trim() ? customPromptArgsInput.trim().split(/\s+/) : [];
+    let selectedKey;
+    let selectedTechnologies = [];
+    let selectedSkills = [];
+    let checkCommand;
+    let testCommand;
+    if (useDefaults) {
+        // Use defaults: Claude CLI + Node.js
+        selectedCliProviderKey = "claude";
+        const provider = CLI_PROVIDERS[selectedCliProviderKey];
         cliConfig = {
-            command: customCommand || "claude",
-            args: customArgs,
-            yoloArgs: customYoloArgs.length > 0 ? customYoloArgs : undefined,
-            promptArgs: customPromptArgs,
+            command: provider.command,
+            args: provider.defaultArgs,
+            yoloArgs: provider.yoloArgs.length > 0 ? provider.yoloArgs : undefined,
+            promptArgs: provider.promptArgs ?? [],
         };
+        selectedKey = "node";
+        const config = LANGUAGES[selectedKey];
+        checkCommand = config.checkCommand;
+        testCommand = config.testCommand;
+        console.log(`Using defaults: ${CLI_PROVIDERS[selectedCliProviderKey].name} + ${LANGUAGES[selectedKey].name}`);
     }
     else {
-        cliConfig = {
-            command: selectedProvider.command,
-            args: selectedProvider.defaultArgs,
-            yoloArgs: selectedProvider.yoloArgs.length > 0 ? selectedProvider.yoloArgs : undefined,
-            promptArgs: selectedProvider.promptArgs ?? [],
-        };
-    }
-    console.log(`\nSelected CLI provider: ${CLI_PROVIDERS[selectedCliProviderKey].name}`);
-    // Step 2: Select language (second)
-    const LANGUAGES = getLanguages();
-    const languageKeys = Object.keys(LANGUAGES);
-    const languageNames = languageKeys.map(k => `${LANGUAGES[k].name} - ${LANGUAGES[k].description}`);
-    const selectedName = await promptSelectWithArrows("Select your project language/runtime:", languageNames);
-    const selectedIndex = languageNames.indexOf(selectedName);
-    const selectedKey = languageKeys[selectedIndex];
-    const config = LANGUAGES[selectedKey];
-    console.log(`\nSelected language: ${config.name}`);
-    // Step 3: Select technology stack if available (third)
-    let selectedTechnologies = [];
-    if (config.technologies && config.technologies.length > 0) {
-        const techOptions = config.technologies.map(t => `${t.name} - ${t.description}`);
-        const techNames = config.technologies.map(t => t.name);
-        selectedTechnologies = await promptMultiSelectWithArrows("Select your technology stack (optional):", techOptions);
-        // Convert display names back to just technology names for predefined options
-        selectedTechnologies = selectedTechnologies.map(sel => {
-            const idx = techOptions.indexOf(sel);
-            return idx >= 0 ? techNames[idx] : sel;
-        });
-        if (selectedTechnologies.length > 0) {
-            console.log(`\nSelected technologies: ${selectedTechnologies.join(", ")}`);
+        // Step 1: Select CLI provider (first)
+        const providerKeys = Object.keys(CLI_PROVIDERS);
+        const providerNames = providerKeys.map(k => `${CLI_PROVIDERS[k].name} - ${CLI_PROVIDERS[k].description}`);
+        const selectedProviderName = await promptSelectWithArrows("Select your AI CLI provider:", providerNames);
+        const selectedProviderIndex = providerNames.indexOf(selectedProviderName);
+        selectedCliProviderKey = providerKeys[selectedProviderIndex];
+        const selectedProvider = CLI_PROVIDERS[selectedCliProviderKey];
+        // Handle custom CLI provider
+        if (selectedCliProviderKey === "custom") {
+            const customCommand = await promptInput("\nEnter your CLI command: ");
+            const customArgsInput = await promptInput("Enter default arguments (space-separated): ");
+            const customArgs = customArgsInput.trim() ? customArgsInput.trim().split(/\s+/) : [];
+            const customYoloArgsInput = await promptInput("Enter yolo/auto-approve arguments (space-separated): ");
+            const customYoloArgs = customYoloArgsInput.trim() ? customYoloArgsInput.trim().split(/\s+/) : [];
+            const customPromptArgsInput = await promptInput("Enter prompt arguments (e.g., -p for flag-based, leave empty for positional): ");
+            const customPromptArgs = customPromptArgsInput.trim() ? customPromptArgsInput.trim().split(/\s+/) : [];
+            cliConfig = {
+                command: customCommand || "claude",
+                args: customArgs,
+                yoloArgs: customYoloArgs.length > 0 ? customYoloArgs : undefined,
+                promptArgs: customPromptArgs,
+            };
         }
         else {
-            console.log("\nNo technologies selected.");
+            cliConfig = {
+                command: selectedProvider.command,
+                args: selectedProvider.defaultArgs,
+                yoloArgs: selectedProvider.yoloArgs.length > 0 ? selectedProvider.yoloArgs : undefined,
+                promptArgs: selectedProvider.promptArgs ?? [],
+            };
+        }
+        console.log(`\nSelected CLI provider: ${CLI_PROVIDERS[selectedCliProviderKey].name}`);
+        // Step 2: Select language (second)
+        const languageKeys = Object.keys(LANGUAGES);
+        const languageNames = languageKeys.map(k => `${LANGUAGES[k].name} - ${LANGUAGES[k].description}`);
+        const selectedName = await promptSelectWithArrows("Select your project language/runtime:", languageNames);
+        const selectedIndex = languageNames.indexOf(selectedName);
+        selectedKey = languageKeys[selectedIndex];
+        const config = LANGUAGES[selectedKey];
+        console.log(`\nSelected language: ${config.name}`);
+        // Step 3: Select technology stack if available (third)
+        if (config.technologies && config.technologies.length > 0) {
+            const techOptions = config.technologies.map(t => `${t.name} - ${t.description}`);
+            const techNames = config.technologies.map(t => t.name);
+            selectedTechnologies = await promptMultiSelectWithArrows("Select your technology stack (optional):", techOptions);
+            // Convert display names back to just technology names for predefined options
+            selectedTechnologies = selectedTechnologies.map(sel => {
+                const idx = techOptions.indexOf(sel);
+                return idx >= 0 ? techNames[idx] : sel;
+            });
+            if (selectedTechnologies.length > 0) {
+                console.log(`\nSelected technologies: ${selectedTechnologies.join(", ")}`);
+            }
+            else {
+                console.log("\nNo technologies selected.");
+            }
+        }
+        // Step 4: Select skills if available for this language
+        const availableSkills = getSkillsForLanguage(selectedKey);
+        if (availableSkills.length > 0) {
+            const skillOptions = availableSkills.map(s => `${s.name} - ${s.description}`);
+            const selectedSkillNames = await promptMultiSelectWithArrows("Select AI coding rules/skills to enable (optional):", skillOptions);
+            // Convert selected display names to SkillConfig objects
+            selectedSkills = selectedSkillNames.map(sel => {
+                const idx = skillOptions.indexOf(sel);
+                const skill = availableSkills[idx];
+                return {
+                    name: skill.name,
+                    description: skill.description,
+                    instructions: skill.instructions,
+                    userInvocable: skill.userInvocable,
+                };
+            });
+            if (selectedSkills.length > 0) {
+                console.log(`\nSelected skills: ${selectedSkills.map(s => s.name).join(", ")}`);
+            }
+            else {
+                console.log("\nNo skills selected.");
+            }
+        }
+        // Allow custom commands for "none" language
+        checkCommand = config.checkCommand;
+        testCommand = config.testCommand;
+        if (selectedKey === "none") {
+            checkCommand = await promptInput("\nEnter your type/build check command: ") || checkCommand;
+            testCommand = await promptInput("Enter your test command: ") || testCommand;
         }
-    }
-    // Allow custom commands for "none" language
-    let checkCommand = config.checkCommand;
-    let testCommand = config.testCommand;
-    if (selectedKey === "none") {
-        checkCommand = await promptInput("\nEnter your type/build check command: ") || checkCommand;
-        testCommand = await promptInput("Enter your test command: ") || testCommand;
     }
     const finalConfig = {
-        ...config,
+        ...LANGUAGES[selectedKey],
         checkCommand,
         testCommand,
     };
     // Generate image name from directory name
     const projectName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
     const imageName = `ralph-${projectName}`;
-    // Write config file
+    // Write config file with all available options (defaults or empty values)
     const configData = {
+        // Required fields
         language: selectedKey,
         checkCommand: finalConfig.checkCommand,
         testCommand: finalConfig.testCommand,
         imageName,
+        // CLI configuration
         cli: cliConfig,
         cliProvider: selectedCliProviderKey,
+        // Optional fields with defaults/empty values for discoverability
+        notifyCommand: "",
+        technologies: selectedTechnologies.length > 0 ? selectedTechnologies : [],
+        javaVersion: selectedKey === "java" ? 21 : null,
+        // Docker configuration options
+        docker: {
+            ports: [],
+            volumes: [],
+            environment: {},
+            git: {
+                name: "",
+                email: "",
+            },
+            packages: [],
+            buildCommands: {
+                root: [],
+                node: [],
+            },
+            startCommand: "",
+            asciinema: {
+                enabled: false,
+                autoRecord: false,
+                outputDir: ".recordings",
+                streamJson: {
+                    enabled: false,
+                    saveRawJson: true,
+                },
+            },
+            firewall: {
+                allowedDomains: [],
+            },
+        },
+        // Claude-specific configuration (MCP servers and skills)
+        claude: {
+            mcpServers: {},
+            skills: selectedSkills,
+        },
     };
-    // Add technologies if any were selected
-    if (selectedTechnologies.length > 0) {
-        configData.technologies = selectedTechnologies;
-    }
     const configPath = join(ralphDir, CONFIG_FILE);
     writeFileSync(configPath, JSON.stringify(configData, null, 2) + "\n");
     console.log(`\nCreated ${RALPH_DIR}/${CONFIG_FILE}`);
     // Write prompt file (ask if exists) - uses template with $variables
     const prompt = generatePromptTemplate();
     const promptPath = join(ralphDir, PROMPT_FILE);
-    if (existsSync(promptPath)) {
+    if (existsSync(promptPath) && !useDefaults) {
         const overwritePrompt = await promptConfirm(`${RALPH_DIR}/${PROMPT_FILE} already exists. Overwrite?`);
         if (overwritePrompt) {
             writeFileSync(promptPath, prompt + "\n");
@@ -137,7 +221,7 @@ export async function init(_args) {
     }
     else {
         writeFileSync(promptPath, prompt + "\n");
-        console.log(`Created ${RALPH_DIR}/${PROMPT_FILE}`);
+        console.log(`${existsSync(promptPath) ? "Updated" : "Created"} ${RALPH_DIR}/${PROMPT_FILE}`);
     }
     // Create PRD if not exists
     const prdPath = join(ralphDir, PRD_FILE);

package/dist/commands/once.js

@@ -1,6 +1,139 @@
 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";
+/**
+ * Parses a stream-json line and extracts displayable text.
+ * Formats output similar to Claude Code's normal terminal display.
+ */
+function parseStreamJsonLine(line, debug = false) {
+    try {
+        const json = JSON.parse(line);
+        if (debug && json.type) {
+            process.stderr.write(`[stream-json] type: ${json.type}\n`);
+        }
+        // Handle Claude Code CLI stream-json events
+        const type = json.type;
+        switch (type) {
+            // === Text Content ===
+            case "content_block_delta":
+                // Incremental text updates - the main streaming content
+                if (json.delta?.type === "text_delta") {
+                    return json.delta.text || "";
+                }
+                // Tool input being streamed
+                if (json.delta?.type === "input_json_delta") {
+                    return ""; // Don't show partial JSON, wait for complete tool call
+                }
+                return json.delta?.text || "";
+            case "text":
+                return json.text || "";
+            // === Tool Use ===
+            case "content_block_start":
+                if (json.content_block?.type === "tool_use") {
+                    const toolName = json.content_block?.name || "unknown";
+                    return `\n── Tool: ${toolName} ──\n`;
+                }
+                if (json.content_block?.type === "text") {
+                    return json.content_block?.text || "";
+                }
+                return "";
+            case "content_block_stop":
+                // End of a content block - add newline after tool use
+                return "";
+            // === Tool Results ===
+            case "tool_result":
+                const toolOutput = json.content || json.output || "";
+                const truncated = typeof toolOutput === "string" && toolOutput.length > 500
+                    ? toolOutput.substring(0, 500) + "... (truncated)"
+                    : toolOutput;
+                return `\n── Tool Result ──\n${typeof truncated === "string" ? truncated : JSON.stringify(truncated, null, 2)}\n`;
+            // === Assistant Messages ===
+            case "assistant":
+                const contents = json.message?.content || json.content || [];
+                let output = "";
+                for (const block of contents) {
+                    if (block.type === "text") {
+                        output += block.text || "";
+                    }
+                    else if (block.type === "tool_use") {
+                        output += `\n── Tool: ${block.name} ──\n`;
+                        if (block.input) {
+                            output += JSON.stringify(block.input, null, 2) + "\n";
+                        }
+                    }
+                }
+                return output;
+            case "message_start":
+                // Beginning of a new message
+                return "\n";
+            case "message_delta":
+                // Message completion info (stop_reason, usage)
+                if (json.delta?.stop_reason) {
+                    return `\n[${json.delta.stop_reason}]\n`;
+                }
+                return "";
+            case "message_stop":
+                return "\n";
+            // === System/User Events ===
+            case "system":
+                if (json.message) {
+                    return `[System] ${json.message}\n`;
+                }
+                return "";
+            case "user":
+                // User message echo - usually not needed to display
+                return "";
+            // === Results and Errors ===
+            case "result":
+                if (json.result !== undefined) {
+                    return `\n── Result ──\n${JSON.stringify(json.result, null, 2)}\n`;
+                }
+                return "";
+            case "error":
+                const errMsg = json.error?.message || JSON.stringify(json.error);
+                return `\n[Error] ${errMsg}\n`;
+            // === File Operations (Claude Code specific) ===
+            case "file_edit":
+            case "file_write":
+                const filePath = json.path || json.file || "unknown";
+                return `\n── Writing: ${filePath} ──\n`;
+            case "file_read":
+                const readPath = json.path || json.file || "unknown";
+                return `── Reading: ${readPath} ──\n`;
+            case "bash":
+            case "command":
+                const cmd = json.command || json.content || "";
+                return `\n── Running: ${cmd} ──\n`;
+            case "bash_output":
+            case "command_output":
+                const cmdOutput = json.output || json.content || "";
+                return cmdOutput + "\n";
+            default:
+                // Fallback: check for common text fields
+                if (json.text)
+                    return json.text;
+                if (json.content && typeof json.content === "string")
+                    return json.content;
+                if (json.message && typeof json.message === "string")
+                    return json.message;
+                if (json.output && typeof json.output === "string")
+                    return json.output;
+                if (debug) {
+                    process.stderr.write(`[stream-json] unhandled type: ${type}, keys: ${Object.keys(json).join(", ")}\n`);
+                }
+                return "";
+        }
+    }
+    catch (e) {
+        // Not valid JSON
+        if (debug) {
+            process.stderr.write(`[stream-json] parse error: ${e}\n`);
+        }
+        return "";
+    }
+}
 export async function once(args) {
     // Parse flags
     let debug = false;
@@ -32,7 +165,19 @@ 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";
+    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"];
@@ -42,6 +187,20 @@ export async function once(args) {
         ...(cliConfig.args ?? []),
         ...yoloArgs,
     ];
+    // Add stream-json output format if enabled
+    let jsonLogPath;
+    if (streamJsonEnabled) {
+        cliArgs.push("--output-format", "stream-json", "--verbose", "--print");
+        // 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 +208,98 @@ 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`);
+        }
     }
     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}`));
-        });
+        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
+                        const text = parseStreamJsonLine(trimmedLine, debug);
+                        if (text) {
+                            process.stdout.write(text);
+                        }
+                    }
+                    else {
+                        // Non-JSON line - display as-is (might be status messages, errors, etc.)
+                        process.stdout.write(trimmedLine + "\n");
+                    }
+                }
+            });
+            proc.on("close", (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 = parseStreamJsonLine(trimmedLine, debug);
+                        if (text) {
+                            process.stdout.write(text);
+                        }
+                    }
+                    else {
+                        // Non-JSON remaining content
+                        process.stdout.write(trimmedLine + "\n");
+                    }
+                }
+                // Ensure final newline
+                process.stdout.write("\n");
+                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}`));
+            });
+        }
+        else {
+            // Standard mode: pass through all I/O
+            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}`));
+            });
+        }
     });
 }