ralph-cli-sandboxed 0.2.6 → 0.2.8

package/dist/templates/prompts.js

@@ -17,6 +17,12 @@ function loadCliProvidersConfig() {
     const content = readFileSync(configPath, "utf-8");
     return JSON.parse(content);
 }
+// Load skills from JSON config file
+function loadSkillsConfig() {
+    const configPath = join(__dirname, "..", "config", "skills.json");
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+}
 // Convert JSON config to the legacy format for compatibility
 function convertToLanguageConfig(config) {
     return {
@@ -31,6 +37,7 @@ function convertToLanguageConfig(config) {
 let _languagesCache = null;
 let _languagesJsonCache = null;
 let _cliProvidersCache = null;
+let _skillsCache = null;
 export function getLanguagesJson() {
     if (!_languagesJsonCache) {
         _languagesJsonCache = loadLanguagesConfig();
@@ -46,6 +53,16 @@ export function getCliProvidersJson() {
 export function getCliProviders() {
     return getCliProvidersJson().providers;
 }
+export function getSkillsJson() {
+    if (!_skillsCache) {
+        _skillsCache = loadSkillsConfig();
+    }
+    return _skillsCache;
+}
+export function getSkillsForLanguage(language) {
+    const skills = getSkillsJson().skills;
+    return skills[language] || [];
+}
 export function getLanguages() {
     if (!_languagesCache) {
         const json = getLanguagesJson();

package/dist/utils/config.d.ts

@@ -4,6 +4,7 @@ export interface CliConfig {
     yoloArgs?: string[];
     promptArgs?: string[];
     modelArgs?: string[];
+    fileArgs?: string[];
 }
 export interface McpServerConfig {
     command: string;
@@ -16,10 +17,15 @@ export interface SkillConfig {
     instructions: string;
     userInvocable?: boolean;
 }
+export interface StreamJsonConfig {
+    enabled: boolean;
+    saveRawJson?: boolean;
+}
 export interface AsciinemaConfig {
     enabled: boolean;
     autoRecord?: boolean;
     outputDir?: string;
+    streamJson?: StreamJsonConfig;
 }
 export interface RalphConfig {
     language: string;

package/dist/utils/config.js

@@ -3,7 +3,7 @@ import { join } from "path";
 import { getCliProviders } from "../templates/prompts.js";
 export const DEFAULT_CLI_CONFIG = {
     command: "claude",
-    args: ["--permission-mode", "acceptEdits"],
+    args: [],
     promptArgs: ["-p"],
 };
 export function getCliConfig(config) {
@@ -21,6 +21,10 @@ export function getCliConfig(config) {
         if (result.modelArgs === undefined && provider?.modelArgs !== undefined) {
             result.modelArgs = provider.modelArgs;
         }
+        // Use provider's fileArgs if not already set
+        if (result.fileArgs === undefined && provider?.fileArgs !== undefined) {
+            result.fileArgs = provider.fileArgs;
+        }
         // Default promptArgs for backwards compatibility
         if (result.promptArgs === undefined) {
             result.promptArgs = ["-p"];

package/dist/utils/notification.d.ts

@@ -0,0 +1,28 @@
+export interface NotificationOptions {
+    /** The notification command from config (e.g., "ntfy pub mytopic" or "notify-send") */
+    command?: string;
+    /** Whether to enable debug output */
+    debug?: boolean;
+}
+export type NotificationEvent = "prd_complete" | "iteration_complete" | "run_stopped" | "error";
+/**
+ * Send a notification using the configured notify command.
+ *
+ * The notification command is split by spaces, with the message appended as the last argument.
+ * This supports various notification tools:
+ * - ntfy: "ntfy pub mytopic" → "ntfy pub mytopic 'message'"
+ * - notify-send: "notify-send Ralph" → "notify-send Ralph 'message'"
+ * - terminal-notifier: "terminal-notifier -title Ralph -message" → "terminal-notifier -title Ralph -message 'message'"
+ * - Custom scripts: "/path/to/notify.sh" → "/path/to/notify.sh 'message'"
+ *
+ * @param event The type of notification event
+ * @param message Optional custom message (default message based on event)
+ * @param options Notification options including the command
+ * @returns Promise that resolves when notification is sent (or immediately if no command configured)
+ */
+export declare function sendNotification(event: NotificationEvent, message?: string, options?: NotificationOptions): Promise<void>;
+/**
+ * Create a notifier function bound to specific options.
+ * Useful for creating a reusable notifier within a command.
+ */
+export declare function createNotifier(options: NotificationOptions): (event: NotificationEvent, message?: string) => Promise<void>;

package/dist/utils/notification.js

@@ -0,0 +1,69 @@
+import { spawn } from "child_process";
+/**
+ * Send a notification using the configured notify command.
+ *
+ * The notification command is split by spaces, with the message appended as the last argument.
+ * This supports various notification tools:
+ * - ntfy: "ntfy pub mytopic" → "ntfy pub mytopic 'message'"
+ * - notify-send: "notify-send Ralph" → "notify-send Ralph 'message'"
+ * - terminal-notifier: "terminal-notifier -title Ralph -message" → "terminal-notifier -title Ralph -message 'message'"
+ * - Custom scripts: "/path/to/notify.sh" → "/path/to/notify.sh 'message'"
+ *
+ * @param event The type of notification event
+ * @param message Optional custom message (default message based on event)
+ * @param options Notification options including the command
+ * @returns Promise that resolves when notification is sent (or immediately if no command configured)
+ */
+export function sendNotification(event, message, options) {
+    return new Promise((resolve) => {
+        const { command, debug } = options ?? {};
+        // No notification if command is not configured or empty
+        if (!command || command.trim() === "") {
+            if (debug) {
+                console.error("[notification] No notifyCommand configured, skipping notification");
+            }
+            resolve();
+            return;
+        }
+        // Generate default message based on event type
+        const defaultMessages = {
+            prd_complete: "Ralph: PRD Complete! All tasks finished.",
+            iteration_complete: "Ralph: Iteration complete.",
+            run_stopped: "Ralph: Run stopped.",
+            error: "Ralph: An error occurred.",
+        };
+        const finalMessage = message ?? defaultMessages[event];
+        // Split command into executable and args
+        const parts = command.trim().split(/\s+/);
+        const [cmd, ...cmdArgs] = parts;
+        if (debug) {
+            console.error(`[notification] Sending: ${cmd} ${[...cmdArgs, finalMessage].join(" ")}`);
+        }
+        // Spawn the notification process, appending the message as the last argument
+        const proc = spawn(cmd, [...cmdArgs, finalMessage], {
+            stdio: "ignore",
+            // Don't let notification process block ralph from exiting
+            detached: true,
+        });
+        // Unref so the parent process can exit independently
+        proc.unref();
+        proc.on("error", (err) => {
+            if (debug) {
+                console.error(`[notification] Failed to send notification: ${err.message}`);
+            }
+            // Don't reject - notification failures shouldn't break ralph
+            resolve();
+        });
+        proc.on("spawn", () => {
+            // Notification process started successfully
+            resolve();
+        });
+    });
+}
+/**
+ * Create a notifier function bound to specific options.
+ * Useful for creating a reusable notifier within a command.
+ */
+export function createNotifier(options) {
+    return (event, message) => sendNotification(event, message, options);
+}

package/dist/utils/stream-json.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Stream JSON parser interface and provider-specific implementations.
+ *
+ * Each CLI provider has its own stream-json event format. This module provides
+ * a unified interface for parsing stream-json output from different providers.
+ */
+/**
+ * Interface for parsing stream-json lines from CLI providers.
+ */
+export interface StreamJsonParser {
+    /**
+     * Parse a single line of stream-json output and return displayable text.
+     * @param line - A single line of JSON output
+     * @returns Human-readable text to display, or empty string if nothing to show
+     */
+    parseStreamJsonLine(line: string): string;
+}
+/**
+ * Base class for stream-json parsers with common utilities.
+ */
+declare abstract class BaseStreamParser implements StreamJsonParser {
+    protected debug: boolean;
+    constructor(debug?: boolean);
+    abstract parseStreamJsonLine(line: string): string;
+    protected debugLog(message: string): void;
+    protected truncateOutput(output: string | unknown, maxLength?: number): string;
+}
+/**
+ * Parser for Claude Code CLI stream-json events.
+ *
+ * Event types:
+ * - content_block_delta: Incremental text updates (text_delta, input_json_delta)
+ * - content_block_start: Tool use or text block start
+ * - content_block_stop: End of content block
+ * - tool_result: Tool execution results
+ * - assistant: Complete assistant message with content blocks
+ * - message_start/message_delta/message_stop: Message lifecycle
+ * - system/user: System and user messages
+ * - result/error: Final results or errors
+ * - file_edit/file_write/file_read: File operations
+ * - bash/command: Command execution
+ * - bash_output/command_output: Command results
+ */
+export declare class ClaudeStreamParser extends BaseStreamParser {
+    parseStreamJsonLine(line: string): string;
+    private handleFallback;
+}
+/**
+ * Parser for Gemini CLI stream-json events.
+ *
+ * Event types:
+ * - initialization: Model initialization info
+ * - messages: Conversation messages
+ * - tools: Tool calls and results
+ * - turn_complete: End of turn
+ * - response: Final response text
+ */
+export declare class GeminiStreamParser extends BaseStreamParser {
+    parseStreamJsonLine(line: string): string;
+    private handleFallback;
+}
+/**
+ * Parser for OpenCode CLI stream-json events.
+ *
+ * Event types:
+ * - step_start/step_end/step_finish: Step lifecycle
+ * - tool_use: Tool invocation with nested part structure (part.type="tool", part.tool, part.state)
+ * - tool/tool_call: Direct tool invocation (alternate format)
+ * - tool_response: Tool results
+ * - text: Text output with nested part structure (part.text)
+ * - assistant_message/model_response: Model output
+ * - thinking/reasoning: Thinking process
+ * - done/complete: Completion
+ */
+export declare class OpenCodeStreamParser extends BaseStreamParser {
+    parseStreamJsonLine(line: string): string;
+    private handleFallback;
+}
+/**
+ * Parser for Codex CLI stream-json events.
+ *
+ * Event types:
+ * - thread.started: Thread initialization
+ * - turn.started/turn.completed/turn.failed: Turn lifecycle
+ * - item.started/item.completed/item.failed: Action lifecycle
+ *   - command_execution, file_change, file_read, mcp_tool_call, web_search, plan_update
+ */
+export declare class CodexStreamParser extends BaseStreamParser {
+    parseStreamJsonLine(line: string): string;
+    private handleFallback;
+}
+/**
+ * Parser for Goose CLI stream-json events.
+ *
+ * Goose uses a similar event format to Claude Code.
+ * Falls back to Claude parser behavior for common events.
+ */
+export declare class GooseStreamParser extends BaseStreamParser {
+    private claudeParser;
+    constructor(debug?: boolean);
+    parseStreamJsonLine(line: string): string;
+}
+/**
+ * Parser for Aider CLI stream events.
+ *
+ * Aider's --stream flag outputs JSON events for:
+ * - text: Streamed text content
+ * - tool_call: Tool/function calls
+ * - tool_result: Tool execution results
+ * - file_edit: File modifications
+ * - error: Error messages
+ */
+export declare class AiderStreamParser extends BaseStreamParser {
+    parseStreamJsonLine(line: string): string;
+    private handleFallback;
+}
+/**
+ * Universal fallback parser that handles common event patterns.
+ * Used for providers without specific stream-json support or as a fallback.
+ */
+export declare class DefaultStreamParser extends BaseStreamParser {
+    parseStreamJsonLine(line: string): string;
+}
+/**
+ * Get the appropriate stream-json parser for a CLI provider.
+ *
+ * @param provider - The CLI provider name (e.g., "claude", "gemini", "opencode")
+ * @param debug - Enable debug logging
+ * @returns The appropriate StreamJsonParser for the provider
+ */
+export declare function getStreamJsonParser(provider: string | undefined, debug?: boolean): StreamJsonParser;
+export {};