ralph-cli-sandboxed 0.4.1 → 0.4.2

package/dist/responders/llm-responder.js

@@ -0,0 +1,582 @@
+/**
+ * LLM Responder - Sends messages to LLM providers and returns responses.
+ * Used by chat clients to respond to messages matched by the responder matcher.
+ */
+import { getLLMProviders, loadConfig, } from "../utils/config.js";
+import { createLLMClient } from "../utils/llm-client.js";
+import { createResponderLog } from "../utils/responder-logger.js";
+import { basename, resolve } from "path";
+import { execSync } from "child_process";
+import { existsSync, readFileSync, statSync } from "fs";
+/**
+ * Default max length for chat responses (characters).
+ */
+const DEFAULT_MAX_LENGTH = 2000;
+/**
+ * Default timeout for LLM requests (milliseconds).
+ */
+const DEFAULT_TIMEOUT = 60000;
+/**
+ * Replaces {{project}} placeholder in system prompt with actual project name.
+ */
+export function applyProjectPlaceholder(systemPrompt, projectName) {
+    return systemPrompt.replace(/\{\{project\}\}/g, projectName);
+}
+/**
+ * Gets the project name from the current working directory.
+ */
+export function getProjectName() {
+    return basename(process.cwd());
+}
+const GIT_DIFF_PATTERNS = [
+    // "diff" or "changes" - show unstaged changes
+    { pattern: /^(diff|changes)$/i, command: "git diff", description: "unstaged changes" },
+    // "staged" - show staged changes
+    { pattern: /^staged$/i, command: "git diff --cached", description: "staged changes" },
+    // "last" or "last commit" - show last commit
+    {
+        pattern: /^(last|last\s*commit)$/i,
+        command: "git show HEAD --stat --patch",
+        description: "last commit",
+    },
+    // "HEAD~N" - show specific commit
+    { pattern: /^HEAD~(\d+)$/i, command: "git show HEAD~$1 --stat --patch", description: "commit" },
+    // "all" - show all uncommitted changes (staged + unstaged)
+    { pattern: /^all$/i, command: "git diff HEAD", description: "all uncommitted changes" },
+];
+/**
+ * Maximum length for git diff output to avoid overwhelming the LLM.
+ */
+const MAX_DIFF_LENGTH = 8000;
+/**
+ * Detects if the message contains a git diff request and fetches the diff.
+ * Returns the message with diff content prepended, or the original message if no diff requested.
+ */
+export function processGitDiffRequest(message) {
+    const trimmed = message.trim();
+    // Check each pattern
+    for (const { pattern, command, description } of GIT_DIFF_PATTERNS) {
+        const match = trimmed.match(pattern);
+        if (match) {
+            try {
+                // Build the actual command (replace $1 with capture group if present)
+                let gitCommand = command;
+                if (match[1] && command.includes("$1")) {
+                    gitCommand = command.replace("$1", match[1]);
+                }
+                // Execute git command
+                const diff = execSync(gitCommand, {
+                    encoding: "utf-8",
+                    maxBuffer: 1024 * 1024, // 1MB buffer
+                    timeout: 10000, // 10 second timeout
+                }).trim();
+                if (!diff) {
+                    return {
+                        message: `No ${description} found. The working directory is clean.`,
+                        diffIncluded: false,
+                        gitCommand,
+                    };
+                }
+                // Truncate if too long
+                let diffContent = diff;
+                let truncatedNote = "";
+                if (diff.length > MAX_DIFF_LENGTH) {
+                    diffContent = diff.slice(0, MAX_DIFF_LENGTH);
+                    truncatedNote = "\n\n[... diff truncated due to length ...]";
+                }
+                return {
+                    message: `Here is the ${description} to review:\n\n\`\`\`diff\n${diffContent}${truncatedNote}\n\`\`\`\n\nPlease review these changes.`,
+                    diffIncluded: true,
+                    gitCommand,
+                    diffLength: diff.length,
+                };
+            }
+            catch (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                // Check if it's not a git repository
+                if (error.includes("not a git repository")) {
+                    return {
+                        message: `Cannot fetch git diff: not in a git repository.`,
+                        diffIncluded: false,
+                    };
+                }
+                return {
+                    message: `Failed to fetch ${description}: ${error}`,
+                    diffIncluded: false,
+                };
+            }
+        }
+    }
+    // No git diff pattern matched, return original message
+    return { message, diffIncluded: false };
+}
+/**
+ * Maximum total size for included files (to avoid overwhelming the LLM).
+ */
+const MAX_FILE_CONTENT_LENGTH = 15000;
+/**
+ * Maximum size for a single file.
+ */
+const MAX_SINGLE_FILE_LENGTH = 8000;
+/**
+ * Supported file extensions for auto-detection.
+ */
+const SUPPORTED_EXTENSIONS = [
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "py",
+    "rb",
+    "go",
+    "rs",
+    "java",
+    "c",
+    "cpp",
+    "h",
+    "hpp",
+    "cs",
+    "swift",
+    "kt",
+    "scala",
+    "php",
+    "sh",
+    "bash",
+    "zsh",
+    "json",
+    "yaml",
+    "yml",
+    "toml",
+    "xml",
+    "html",
+    "css",
+    "scss",
+    "less",
+    "md",
+    "txt",
+    "sql",
+    "graphql",
+    "proto",
+    "dockerfile",
+    "makefile",
+    "env",
+    "gitignore",
+    "config",
+];
+/**
+ * Detects file paths in a message and reads their contents.
+ * Supports formats like:
+ *   - src/utils/config.ts
+ *   - src/utils/config.ts:42 (with line number)
+ *   - ./relative/path.js
+ *   - package.json
+ */
+export function detectAndReadFiles(message) {
+    const result = {
+        filesRead: [],
+        filesNotFound: [],
+        totalLength: 0,
+    };
+    // Pattern to match file paths with optional line numbers
+    // Matches: path/to/file.ext or path/to/file.ext:123
+    const extensionPattern = SUPPORTED_EXTENSIONS.join("|");
+    const filePattern = new RegExp(`(?:^|\\s|["'\`(])([\\w./-]+\\.(?:${extensionPattern}))(?::(\\d+))?(?=[\\s"'\`),]|$)`, "gi");
+    // Also match common config files without extensions
+    const configFilePattern = /(?:^|\s|["'`(])((?:\.?[\w/-]+)?(?:Dockerfile|Makefile|\.gitignore|\.env(?:\.local)?))(?=[\s"'`),]|$)/gi;
+    const seenFiles = new Set();
+    const matches = [];
+    // Find all file pattern matches
+    let match;
+    while ((match = filePattern.exec(message)) !== null) {
+        const filePath = match[1];
+        const lineNumber = match[2] ? parseInt(match[2], 10) : undefined;
+        if (!seenFiles.has(filePath)) {
+            seenFiles.add(filePath);
+            matches.push({ path: filePath, lineNumber });
+        }
+    }
+    // Find config file matches
+    while ((match = configFilePattern.exec(message)) !== null) {
+        const filePath = match[1];
+        if (!seenFiles.has(filePath)) {
+            seenFiles.add(filePath);
+            matches.push({ path: filePath });
+        }
+    }
+    // Try to read each file
+    for (const { path: filePath, lineNumber } of matches) {
+        // Stop if we've already included too much content
+        if (result.totalLength >= MAX_FILE_CONTENT_LENGTH) {
+            break;
+        }
+        try {
+            // Resolve relative paths
+            const resolvedPath = resolve(process.cwd(), filePath);
+            // Check if file exists and is a file (not directory)
+            if (!existsSync(resolvedPath)) {
+                result.filesNotFound.push(filePath);
+                continue;
+            }
+            const stats = statSync(resolvedPath);
+            if (!stats.isFile()) {
+                continue;
+            }
+            // Check file size before reading
+            if (stats.size > 100000) {
+                // Skip files larger than 100KB
+                result.filesNotFound.push(`${filePath} (too large)`);
+                continue;
+            }
+            // Read the file
+            let content = readFileSync(resolvedPath, "utf-8");
+            let truncated = false;
+            // Truncate if too long
+            if (content.length > MAX_SINGLE_FILE_LENGTH) {
+                content = content.slice(0, MAX_SINGLE_FILE_LENGTH);
+                truncated = true;
+            }
+            // Check if adding this would exceed total limit
+            if (result.totalLength + content.length > MAX_FILE_CONTENT_LENGTH) {
+                const remaining = MAX_FILE_CONTENT_LENGTH - result.totalLength;
+                if (remaining > 500) {
+                    content = content.slice(0, remaining);
+                    truncated = true;
+                }
+                else {
+                    break;
+                }
+            }
+            result.filesRead.push({
+                path: filePath,
+                content,
+                lineNumber,
+                truncated,
+            });
+            result.totalLength += content.length;
+        }
+        catch {
+            result.filesNotFound.push(filePath);
+        }
+    }
+    return result;
+}
+/**
+ * Formats detected files as context to prepend to the user message.
+ */
+export function formatFileContext(fileResult) {
+    if (fileResult.filesRead.length === 0) {
+        return "";
+    }
+    const parts = ["Here are the referenced files:\n"];
+    for (const file of fileResult.filesRead) {
+        const truncatedNote = file.truncated ? " (truncated)" : "";
+        const lineNote = file.lineNumber ? ` (focus on line ${file.lineNumber})` : "";
+        // Detect language for syntax highlighting
+        const ext = file.path.split(".").pop() || "";
+        const langMap = {
+            ts: "typescript",
+            tsx: "typescript",
+            js: "javascript",
+            jsx: "javascript",
+            py: "python",
+            rb: "ruby",
+            go: "go",
+            rs: "rust",
+            java: "java",
+            json: "json",
+            yaml: "yaml",
+            yml: "yaml",
+            md: "markdown",
+            sh: "bash",
+            bash: "bash",
+        };
+        const lang = langMap[ext] || ext;
+        parts.push(`\n**${file.path}**${lineNote}${truncatedNote}:`);
+        parts.push("```" + lang);
+        // If line number specified, add line numbers to help locate
+        if (file.lineNumber) {
+            const lines = file.content.split("\n");
+            const start = Math.max(0, file.lineNumber - 10);
+            const end = Math.min(lines.length, file.lineNumber + 10);
+            const contextLines = lines.slice(start, end);
+            const numberedLines = contextLines.map((line, i) => `${String(start + i + 1).padStart(4, " ")} | ${line}`);
+            parts.push(numberedLines.join("\n"));
+            if (start > 0)
+                parts[parts.length - 1] = "...\n" + parts[parts.length - 1];
+            if (end < lines.length)
+                parts[parts.length - 1] += "\n...";
+        }
+        else {
+            parts.push(file.content);
+        }
+        parts.push("```");
+    }
+    if (fileResult.filesNotFound.length > 0) {
+        parts.push(`\n_Files not found: ${fileResult.filesNotFound.join(", ")}_`);
+    }
+    parts.push("\n---\n");
+    return parts.join("\n");
+}
+/**
+ * Truncates a response to the specified max length.
+ * Adds a truncation indicator if the response was shortened.
+ */
+export function truncateResponse(response, maxLength) {
+    const originalLength = response.length;
+    if (originalLength <= maxLength) {
+        return { text: response, truncated: false, originalLength };
+    }
+    // Leave room for truncation indicator
+    const indicator = "\n\n[...response truncated]";
+    const truncatedLength = maxLength - indicator.length;
+    if (truncatedLength <= 0) {
+        return { text: "[response too long]", truncated: true, originalLength };
+    }
+    // Try to truncate at a sentence or word boundary
+    let text = response.slice(0, truncatedLength);
+    // Look for a good break point (sentence end, then word end)
+    const sentenceEnd = text.lastIndexOf(". ");
+    const paragraphEnd = text.lastIndexOf("\n\n");
+    const wordEnd = text.lastIndexOf(" ");
+    // Prefer paragraph, then sentence, then word boundary
+    if (paragraphEnd > truncatedLength * 0.7) {
+        text = text.slice(0, paragraphEnd);
+    }
+    else if (sentenceEnd > truncatedLength * 0.7) {
+        text = text.slice(0, sentenceEnd + 1); // Include the period
+    }
+    else if (wordEnd > truncatedLength * 0.8) {
+        text = text.slice(0, wordEnd);
+    }
+    return {
+        text: text + indicator,
+        truncated: true,
+        originalLength,
+    };
+}
+/**
+ * Executes an LLM responder with the given message.
+ *
+ * @param message The user message to send to the LLM
+ * @param responderConfig The responder configuration
+ * @param config Optional Ralph config (loaded automatically if not provided)
+ * @param options Optional execution options
+ * @returns The responder result with response or error
+ */
+export async function executeLLMResponder(message, responderConfig, config, options) {
+    try {
+        // Process git diff requests (e.g., "@review diff", "@review last")
+        const gitDiffResult = processGitDiffRequest(message);
+        let processedMessage = gitDiffResult.message;
+        // Detect and read referenced files (e.g., "src/utils/config.ts")
+        const fileResult = detectAndReadFiles(message);
+        const fileContext = formatFileContext(fileResult);
+        if (fileContext) {
+            processedMessage = fileContext + processedMessage;
+        }
+        // Load config if not provided
+        const ralphConfig = config ?? loadConfig();
+        // Get LLM providers
+        const providers = getLLMProviders(ralphConfig);
+        // Get provider name from responder config (default to "anthropic")
+        const providerName = responderConfig.provider ?? "anthropic";
+        // Look up the provider
+        const providerConfig = providers[providerName];
+        if (!providerConfig) {
+            return {
+                success: false,
+                response: "",
+                error: `LLM provider "${providerName}" not found. Available providers: ${Object.keys(providers).join(", ")}`,
+            };
+        }
+        // Create LLM client
+        let client;
+        try {
+            client = createLLMClient(providerConfig);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                response: "",
+                error: `Failed to create LLM client for "${providerName}": ${error}`,
+            };
+        }
+        // Prepare system prompt with project placeholder
+        const projectName = options?.projectName ?? getProjectName();
+        let systemPrompt = responderConfig.systemPrompt;
+        if (systemPrompt) {
+            systemPrompt = applyProjectPlaceholder(systemPrompt, projectName);
+        }
+        // Prepare chat options
+        const chatOptions = {
+            maxTokens: options?.maxTokens,
+            temperature: options?.temperature,
+        };
+        // Prepare messages (use processed message which may include git diff content)
+        // Include conversation history if provided for multi-turn chat
+        const messages = [];
+        if (options?.conversationHistory && options.conversationHistory.length > 0) {
+            for (const msg of options.conversationHistory) {
+                messages.push({ role: msg.role, content: msg.content });
+            }
+        }
+        messages.push({ role: "user", content: processedMessage });
+        // Log the responder call
+        createResponderLog({
+            responderName: options?.responderName,
+            responderType: "llm",
+            trigger: options?.trigger,
+            gitCommand: gitDiffResult.gitCommand,
+            gitDiffLength: gitDiffResult.diffLength,
+            filesRead: fileResult.filesRead.map((f) => f.path),
+            filesNotFound: fileResult.filesNotFound,
+            filesTotalLength: fileResult.totalLength,
+            threadContextLength: options?.threadContextLength,
+            message: processedMessage,
+            systemPrompt,
+            debug: options?.debug,
+        });
+        // Execute with timeout
+        const timeout = responderConfig.timeout ?? DEFAULT_TIMEOUT;
+        const responsePromise = client.chat(messages, systemPrompt, chatOptions);
+        let response;
+        try {
+            response = await Promise.race([
+                responsePromise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), timeout)),
+            ]);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                response: "",
+                error: `LLM request failed: ${error}`,
+            };
+        }
+        // Truncate response if needed
+        const maxLength = responderConfig.maxLength ?? DEFAULT_MAX_LENGTH;
+        const { text, truncated, originalLength } = truncateResponse(response, maxLength);
+        return {
+            success: true,
+            response: text,
+            truncated,
+            originalLength: truncated ? originalLength : undefined,
+        };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        return {
+            success: false,
+            response: "",
+            error: `Unexpected error: ${error}`,
+        };
+    }
+}
+/**
+ * Creates a reusable LLM responder function with pre-loaded configuration.
+ * This is useful for handling multiple messages without reloading config each time.
+ *
+ * @param responderConfig The responder configuration
+ * @param config The Ralph configuration
+ * @returns A function that executes the responder with a message
+ */
+export function createLLMResponder(responderConfig, config) {
+    // Pre-load provider and client
+    const providers = getLLMProviders(config);
+    const providerName = responderConfig.provider ?? "anthropic";
+    const providerConfig = providers[providerName];
+    // Pre-create client if possible
+    let client = null;
+    let clientError = null;
+    if (!providerConfig) {
+        clientError = `LLM provider "${providerName}" not found. Available providers: ${Object.keys(providers).join(", ")}`;
+    }
+    else {
+        try {
+            client = createLLMClient(providerConfig);
+        }
+        catch (err) {
+            clientError = `Failed to create LLM client for "${providerName}": ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    return async (message, options) => {
+        // Return cached error if client creation failed
+        if (clientError || !client) {
+            return {
+                success: false,
+                response: "",
+                error: clientError ?? "LLM client not initialized",
+            };
+        }
+        try {
+            // Prepare system prompt with project placeholder
+            const projectName = options?.projectName ?? getProjectName();
+            let systemPrompt = responderConfig.systemPrompt;
+            if (systemPrompt) {
+                systemPrompt = applyProjectPlaceholder(systemPrompt, projectName);
+            }
+            // Prepare chat options
+            const chatOptions = {
+                maxTokens: options?.maxTokens,
+                temperature: options?.temperature,
+            };
+            // Prepare messages
+            const messages = [{ role: "user", content: message }];
+            // Execute with timeout
+            const timeout = responderConfig.timeout ?? DEFAULT_TIMEOUT;
+            const responsePromise = client.chat(messages, systemPrompt, chatOptions);
+            let response;
+            try {
+                response = await Promise.race([
+                    responsePromise,
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), timeout)),
+                ]);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                return {
+                    success: false,
+                    response: "",
+                    error: `LLM request failed: ${error}`,
+                };
+            }
+            // Truncate response if needed
+            const maxLength = responderConfig.maxLength ?? DEFAULT_MAX_LENGTH;
+            const { text, truncated, originalLength } = truncateResponse(response, maxLength);
+            return {
+                success: true,
+                response: text,
+                truncated,
+                originalLength: truncated ? originalLength : undefined,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                response: "",
+                error: `Unexpected error: ${error}`,
+            };
+        }
+    };
+}
+/**
+ * Validates that a responder configuration is valid for LLM execution.
+ *
+ * @param responderConfig The responder configuration to validate
+ * @param config The Ralph configuration for looking up providers
+ * @returns An error message if invalid, or null if valid
+ */
+export function validateLLMResponder(responderConfig, config) {
+    if (responderConfig.type !== "llm") {
+        return `Responder type is "${responderConfig.type}", expected "llm"`;
+    }
+    const providers = getLLMProviders(config);
+    const providerName = responderConfig.provider ?? "anthropic";
+    if (!providers[providerName]) {
+        return `LLM provider "${providerName}" not found. Available providers: ${Object.keys(providers).join(", ")}`;
+    }
+    return null;
+}

package/dist/templates/macos-scripts.js

@@ -203,15 +203,13 @@ echo "  ./scripts/gen_xcode.sh"
  * Check if the selected technologies include SwiftUI
  */
 export function hasSwiftUI(technologies) {
-    return technologies.some(tech => tech.toLowerCase().includes('swiftui') ||
-        tech.toLowerCase() === 'swiftui');
+    return technologies.some((tech) => tech.toLowerCase().includes("swiftui") || tech.toLowerCase() === "swiftui");
 }
 /**
  * Check if the selected technologies include Fastlane
  */
 export function hasFastlane(technologies) {
-    return technologies.some(tech => tech.toLowerCase().includes('fastlane') ||
-        tech.toLowerCase() === 'fastlane');
+    return technologies.some((tech) => tech.toLowerCase().includes("fastlane") || tech.toLowerCase() === "fastlane");
 }
 /**
  * Generate Fastfile template for macOS/iOS deployment

package/dist/templates/prompts.js

@@ -122,7 +122,9 @@ Now, read the PRD and begin working on the highest priority incomplete feature.`
 export function resolvePromptVariables(template, config) {
     const languageConfig = LANGUAGES[config.language];
     const languageName = languageConfig?.name || config.language;
-    const technologies = config.technologies?.length ? config.technologies.join(", ") : "(none specified)";
+    const technologies = config.technologies?.length
+        ? config.technologies.join(", ")
+        : "(none specified)";
     return template
         .replace(/\$language/g, languageName)
         .replace(/\$technologies/g, technologies)
@@ -133,7 +135,7 @@ export function resolvePromptVariables(template, config) {
 export function generatePrompt(config, technologies) {
     const template = generatePromptTemplate();
     return resolvePromptVariables(template, {
-        language: Object.keys(LANGUAGES).find(k => LANGUAGES[k].name === config.name) || "none",
+        language: Object.keys(LANGUAGES).find((k) => LANGUAGES[k].name === config.name) || "none",
         checkCommand: config.checkCommand,
         testCommand: config.testCommand,
         technologies,

package/dist/tui/ConfigEditor.js

@@ -11,6 +11,8 @@ import { ArrayEditor } from "./components/ArrayEditor.js";
 import { ObjectEditor } from "./components/ObjectEditor.js";
 import { KeyValueEditor } from "./components/KeyValueEditor.js";
 import { JsonSnippetEditor } from "./components/JsonSnippetEditor.js";
+import { LLMProvidersEditor } from "./components/LLMProvidersEditor.js";
+import { RespondersEditor } from "./components/RespondersEditor.js";
 import { Preview } from "./components/Preview.js";
 import { HelpPanel } from "./components/HelpPanel.js";
 import { PresetSelector } from "./components/PresetSelector.js";
@@ -41,7 +43,7 @@ function setValueAtPath(obj, path, value) {
 export function ConfigEditor() {
     const { exit } = useApp();
     const terminalSize = useTerminalSize();
-    const { config, loading, error, hasChanges, saveConfig, updateConfig, } = useConfig();
+    const { config, loading, error, hasChanges, saveConfig, updateConfig } = useConfig();
     // Calculate available height for scrollable content
     // Reserve lines for: header (2), status message (1), footer (2), borders (2)
     const availableHeight = Math.max(8, terminalSize.rows - 7);
@@ -272,15 +274,23 @@ export function ConfigEditor() {
                 for (const [k, v] of Object.entries(objValue)) {
                     stringEntries[k] = typeof v === "string" ? v : JSON.stringify(v);
                 }
+                // Check if this is the llmProviders field
+                const isLLMProviders = selectedField === "llmProviders";
+                if (isLLMProviders) {
+                    return (_jsx(LLMProvidersEditor, { label: currentFieldLabel, providers: currentFieldValue || {}, onConfirm: handleFieldConfirm, onCancel: handleFieldCancel, isFocused: true, maxHeight: editorMaxHeight }));
+                }
+                // Check if this is the chat.responders field
+                const isResponders = selectedField === "chat.responders";
+                if (isResponders) {
+                    return (_jsx(RespondersEditor, { label: currentFieldLabel, responders: currentFieldValue || {}, onConfirm: handleFieldConfirm, onCancel: handleFieldCancel, isFocused: true, maxHeight: editorMaxHeight }));
+                }
                 // Check if this is a notification provider config field
                 const isNotificationProvider = selectedField &&
                     (selectedField === "notifications.ntfy" ||
                         selectedField === "notifications.pushover" ||
                         selectedField === "notifications.gotify");
                 // Check if this is a chat provider config field
-                const isChatProvider = selectedField &&
-                    (selectedField === "chat.slack" ||
-                        selectedField === "chat.telegram");
+                const isChatProvider = selectedField && (selectedField === "chat.slack" || selectedField === "chat.telegram");
                 if (isNotificationProvider || isChatProvider) {
                     // Extract provider name from field path
                     const providerName = selectedField.split(".").pop() || "";
@@ -331,6 +341,10 @@ export function ConfigEditor() {
                 return (_jsx(StringEditor, { label: currentFieldLabel, value: String(currentFieldValue || ""), onConfirm: handleFieldConfirm, onCancel: handleFieldCancel, isFocused: true }));
         }
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [helpVisible && (_jsx(HelpPanel, { visible: helpVisible, onClose: toggleHelp })), _jsxs(Box, { marginBottom: 1, justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: "ralph config" }), hasChanges && _jsx(Text, { color: "yellow", children: " (unsaved changes)" })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "[S] Save" }), _jsx(Text, { dimColor: true, children: " | " }), _jsx(Text, { dimColor: true, children: "[Q] Quit" }), _jsx(Text, { dimColor: true, children: " | " }), _jsx(Text, { dimColor: true, children: "[?] Help" })] })] }), statusMessage && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: statusMessage.includes("Failed") || statusMessage.includes("Validation") ? "red" : "green", children: statusMessage }) })), focusPane === "field-editor" ? (_jsx(Box, { children: renderFieldEditor() })) : focusPane === "preset-selector" ? (_jsx(Box, { children: _jsx(PresetSelector, { sectionId: selectedSection, config: config, onSelectPreset: handleSelectPreset, onSkip: handleSkipPreset, onCancel: handleCancelPreset, isFocused: true }) })) : (_jsxs(Box, { children: [_jsx(Box, { width: 20, children: _jsx(SectionNav, { selectedSection: selectedSection, onSelectSection: handleSelectSection, isFocused: focusPane === "nav", maxHeight: navMaxHeight }) }), _jsx(Box, { flexGrow: 1, children: _jsx(EditorPanel, { config: config, selectedSection: selectedSection, selectedField: selectedField, onSelectField: handleSelectField, onBack: handleBack, isFocused: focusPane === "editor", validationErrors: validationErrors, maxHeight: editorMaxHeight }) }), _jsx(Preview, { config: config, selectedSection: selectedSection, visible: previewVisible })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [focusPane === "nav" && "j/k: navigate | Enter: select | l/→: editor | Tab: toggle preview", focusPane === "editor" && "j/k: navigate | Enter: edit | J: JSON | h/←: nav | Tab: preview | p: presets", focusPane === "field-editor" && "Follow editor hints", focusPane === "preset-selector" && "j/k: navigate | Enter: select | Esc: back"] }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [helpVisible && _jsx(HelpPanel, { visible: helpVisible, onClose: toggleHelp }), _jsxs(Box, { marginBottom: 1, justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: "ralph config" }), hasChanges && _jsx(Text, { color: "yellow", children: " (unsaved changes)" })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "[S] Save" }), _jsx(Text, { dimColor: true, children: " | " }), _jsx(Text, { dimColor: true, children: "[Q] Quit" }), _jsx(Text, { dimColor: true, children: " | " }), _jsx(Text, { dimColor: true, children: "[?] Help" })] })] }), statusMessage && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: statusMessage.includes("Failed") || statusMessage.includes("Validation")
+                        ? "red"
+                        : "green", children: statusMessage }) })), focusPane === "field-editor" ? (_jsx(Box, { children: renderFieldEditor() })) : focusPane === "preset-selector" ? (_jsx(Box, { children: _jsx(PresetSelector, { sectionId: selectedSection, config: config, onSelectPreset: handleSelectPreset, onSkip: handleSkipPreset, onCancel: handleCancelPreset, isFocused: true }) })) : (_jsxs(Box, { children: [_jsx(Box, { width: 20, children: _jsx(SectionNav, { selectedSection: selectedSection, onSelectSection: handleSelectSection, isFocused: focusPane === "nav", maxHeight: navMaxHeight }) }), _jsx(Box, { flexGrow: 1, children: _jsx(EditorPanel, { config: config, selectedSection: selectedSection, selectedField: selectedField, onSelectField: handleSelectField, onBack: handleBack, isFocused: focusPane === "editor", validationErrors: validationErrors, maxHeight: editorMaxHeight }) }), _jsx(Preview, { config: config, selectedSection: selectedSection, visible: previewVisible })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [focusPane === "nav" &&
+                            "j/k: navigate | Enter: select | l/→: editor | Tab: toggle preview", focusPane === "editor" &&
+                            "j/k: navigate | Enter: edit | J: JSON | h/←: nav | Tab: preview | p: presets", focusPane === "field-editor" && "Follow editor hints", focusPane === "preset-selector" && "j/k: navigate | Enter: select | Esc: back"] }) })] }));
 }
 export default ConfigEditor;