ralph-cli-sandboxed 0.4.0 → 0.4.2

package/dist/utils/message-queue.js

@@ -86,14 +86,14 @@ export async function waitForResponse(messagesPath, messageId, timeout = 10000,
     const startTime = Date.now();
     while (Date.now() - startTime < timeout) {
         const messages = readMessages(messagesPath);
-        const message = messages.find(m => m.id === messageId);
+        const message = messages.find((m) => m.id === messageId);
         if (message?.status === "done" && message.response) {
             // Clean up processed message
-            const remaining = messages.filter(m => m.id !== messageId);
+            const remaining = messages.filter((m) => m.id !== messageId);
             writeMessages(messagesPath, remaining);
             return message.response;
         }
-        await new Promise(resolve => setTimeout(resolve, pollInterval));
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
     }
     return null;
 }
@@ -102,14 +102,14 @@ export async function waitForResponse(messagesPath, messageId, timeout = 10000,
  */
 export function getPendingMessages(messagesPath, from) {
     const messages = readMessages(messagesPath);
-    return messages.filter(m => m.from === from && m.status === "pending");
+    return messages.filter((m) => m.from === from && m.status === "pending");
 }
 /**
  * Mark a message as done with a response.
  */
 export function respondToMessage(messagesPath, messageId, response) {
     const messages = readMessages(messagesPath);
-    const message = messages.find(m => m.id === messageId);
+    const message = messages.find((m) => m.id === messageId);
     if (!message) {
         return false;
     }
@@ -124,7 +124,7 @@ export function respondToMessage(messagesPath, messageId, response) {
 export function cleanupOldMessages(messagesPath, maxAge = 60000) {
     const messages = readMessages(messagesPath);
     const now = Date.now();
-    const remaining = messages.filter(m => now - m.timestamp < maxAge);
+    const remaining = messages.filter((m) => now - m.timestamp < maxAge);
     const removed = messages.length - remaining.length;
     if (removed > 0) {
         writeMessages(messagesPath, remaining);

package/dist/utils/notification.d.ts

@@ -1,4 +1,4 @@
-import { DaemonEventType, DaemonConfig } from "./config.js";
+import { DaemonEventType, DaemonConfig, ChatConfig } from "./config.js";
 export interface NotificationOptions {
     /** The notification command from config (e.g., "ntfy pub mytopic" or "notify-send") */
     command?: string;
@@ -8,8 +8,12 @@ export interface NotificationOptions {
     useDaemon?: boolean;
     /** Daemon configuration for event-based notifications */
     daemonConfig?: DaemonConfig;
+    /** Chat configuration for automatic chat notifications */
+    chatConfig?: ChatConfig;
     /** Task name for task_complete events (used in message placeholders) */
     taskName?: string;
+    /** Error message for error events (used in {{error}} placeholder) */
+    errorMessage?: string;
 }
 export type NotificationEvent = "prd_complete" | "iteration_complete" | "run_stopped" | "task_complete" | "error";
 /**
@@ -39,15 +43,19 @@ export declare function createNotifier(options: NotificationOptions): (event: No
  *
  * @param event The daemon event type
  * @param options Notification options containing daemon config
- * @param context Additional context (e.g., task name for task_complete)
+ * @param context Additional context (e.g., task name for task_complete, error message for error)
  */
 export declare function triggerDaemonEvents(event: DaemonEventType, options?: NotificationOptions, context?: {
     taskName?: string;
+    errorMessage?: string;
 }): Promise<void>;
 /**
  * Send notification and also trigger any configured daemon events.
  * This is the recommended function to use for comprehensive notification handling.
  *
+ * When running in a container with chat providers configured (Slack, Telegram, Discord),
+ * notifications are automatically sent to those channels.
+ *
  * @param event The notification event type
  * @param message Optional custom message
  * @param options Notification options

package/dist/utils/notification.js

@@ -1,6 +1,6 @@
 import { spawn } from "child_process";
-import { isRunningInContainer } from "./config.js";
-import { isDaemonAvailable, sendDaemonNotification, sendDaemonRequest } from "./daemon-client.js";
+import { isRunningInContainer, } from "./config.js";
+import { isDaemonAvailable, sendDaemonNotification, sendDaemonRequest, sendSlackNotification, sendTelegramNotification, sendDiscordNotification, } from "./daemon-client.js";
 /**
  * Send a notification using the configured notify command.
  *
@@ -120,7 +120,7 @@ function mapEventToDaemonEvent(event) {
  *
  * @param event The daemon event type
  * @param options Notification options containing daemon config
- * @param context Additional context (e.g., task name for task_complete)
+ * @param context Additional context (e.g., task name for task_complete, error message for error)
  */
 export async function triggerDaemonEvents(event, options, context) {
     const { daemonConfig, debug } = options ?? {};
@@ -150,6 +150,9 @@ export async function triggerDaemonEvents(event, options, context) {
             if (context?.taskName) {
                 message = message.replace(/\{\{task\}\}/g, context.taskName);
             }
+            if (context?.errorMessage) {
+                message = message.replace(/\{\{error\}\}/g, context.errorMessage);
+            }
             // Build args array
             const args = [...(handler.args || [])];
             if (message) {
@@ -176,20 +179,124 @@ export async function triggerDaemonEvents(event, options, context) {
         }
     }
 }
+/**
+ * Send notifications to connected chat providers (Slack, Telegram, Discord).
+ * This automatically sends notifications to all enabled chat providers when
+ * running inside a container with the daemon available.
+ *
+ * @param message The notification message
+ * @param options Notification options containing chat config
+ */
+async function sendChatNotifications(message, options) {
+    const { chatConfig, debug } = options ?? {};
+    // Only send chat notifications when in container with daemon available
+    if (!isRunningInContainer() || !isDaemonAvailable()) {
+        return;
+    }
+    // Check if Slack is configured and enabled
+    const slackEnabled = chatConfig?.slack?.botToken &&
+        chatConfig?.slack?.appToken &&
+        chatConfig?.slack?.signingSecret &&
+        chatConfig?.slack?.enabled !== false;
+    if (slackEnabled) {
+        try {
+            if (debug) {
+                console.error("[notification] Sending Slack notification via daemon");
+            }
+            const response = await sendSlackNotification(message);
+            if (debug) {
+                if (response.success) {
+                    console.error("[notification] Slack notification sent successfully");
+                }
+                else {
+                    console.error(`[notification] Slack notification failed: ${response.error}`);
+                }
+            }
+        }
+        catch (err) {
+            if (debug) {
+                console.error(`[notification] Slack notification error: ${err instanceof Error ? err.message : "unknown"}`);
+            }
+        }
+    }
+    // Check if Telegram is configured and enabled
+    const telegramEnabled = chatConfig?.telegram?.botToken && chatConfig?.telegram?.enabled !== false;
+    if (telegramEnabled) {
+        try {
+            if (debug) {
+                console.error("[notification] Sending Telegram notification via daemon");
+            }
+            const response = await sendTelegramNotification(message);
+            if (debug) {
+                if (response.success) {
+                    console.error("[notification] Telegram notification sent successfully");
+                }
+                else {
+                    console.error(`[notification] Telegram notification failed: ${response.error}`);
+                }
+            }
+        }
+        catch (err) {
+            if (debug) {
+                console.error(`[notification] Telegram notification error: ${err instanceof Error ? err.message : "unknown"}`);
+            }
+        }
+    }
+    // Check if Discord is configured and enabled
+    const discordEnabled = chatConfig?.discord?.botToken && chatConfig?.discord?.enabled !== false;
+    if (discordEnabled) {
+        try {
+            if (debug) {
+                console.error("[notification] Sending Discord notification via daemon");
+            }
+            const response = await sendDiscordNotification(message);
+            if (debug) {
+                if (response.success) {
+                    console.error("[notification] Discord notification sent successfully");
+                }
+                else {
+                    console.error(`[notification] Discord notification failed: ${response.error}`);
+                }
+            }
+        }
+        catch (err) {
+            if (debug) {
+                console.error(`[notification] Discord notification error: ${err instanceof Error ? err.message : "unknown"}`);
+            }
+        }
+    }
+}
 /**
  * Send notification and also trigger any configured daemon events.
  * This is the recommended function to use for comprehensive notification handling.
  *
+ * When running in a container with chat providers configured (Slack, Telegram, Discord),
+ * notifications are automatically sent to those channels.
+ *
  * @param event The notification event type
  * @param message Optional custom message
  * @param options Notification options
  */
 export async function sendNotificationWithDaemonEvents(event, message, options) {
+    // Generate default message based on event type if not provided
+    const defaultMessages = {
+        prd_complete: "Ralph: PRD Complete! All tasks finished.",
+        iteration_complete: "Ralph: Iteration complete.",
+        run_stopped: "Ralph: Run stopped.",
+        task_complete: "Ralph: Task complete.",
+        error: "Ralph: An error occurred.",
+    };
+    const finalMessage = message ?? defaultMessages[event];
     // Send the regular notification
     await sendNotification(event, message, options);
     // Also trigger daemon events if configured
     const daemonEvent = mapEventToDaemonEvent(event);
     if (daemonEvent) {
-        await triggerDaemonEvents(daemonEvent, options, { taskName: options?.taskName });
+        await triggerDaemonEvents(daemonEvent, options, {
+            taskName: options?.taskName,
+            errorMessage: options?.errorMessage,
+        });
     }
+    // Send automatic chat notifications (Slack, Telegram, Discord)
+    await sendChatNotifications(finalMessage, options);
 }

package/dist/utils/prd-validator.js

@@ -45,7 +45,7 @@ export function validatePrd(content) {
             errors.push(`${prefix} missing or invalid 'passes' field (must be boolean)`);
         }
         // If no errors for this item, add to valid data
-        if (errors.filter(e => e.startsWith(prefix)).length === 0) {
+        if (errors.filter((e) => e.startsWith(prefix)).length === 0) {
             data.push({
                 category: entry.category,
                 description: entry.description,
@@ -125,7 +125,16 @@ function extractFromItem(item) {
         return null;
     }
     // Find passes status - check various field names and values
-    const passesFields = ["passes", "pass", "passed", "done", "complete", "completed", "status", "finished"];
+    const passesFields = [
+        "passes",
+        "pass",
+        "passed",
+        "done",
+        "complete",
+        "completed",
+        "status",
+        "finished",
+    ];
     let passes = false;
     for (const field of passesFields) {
         const value = obj[field];
@@ -135,7 +144,13 @@ function extractFromItem(item) {
         }
         if (typeof value === "string") {
             const lower = value.toLowerCase();
-            if (lower === "true" || lower === "pass" || lower === "passed" || lower === "done" || lower === "complete" || lower === "completed" || lower === "finished") {
+            if (lower === "true" ||
+                lower === "pass" ||
+                lower === "passed" ||
+                lower === "done" ||
+                lower === "complete" ||
+                lower === "completed" ||
+                lower === "finished") {
                 passes = true;
                 break;
             }
@@ -147,12 +162,18 @@ function extractFromItem(item) {
  * Calculates similarity between two strings using Jaccard index on words.
  */
 function similarity(a, b) {
-    const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(w => w.length > 2));
-    const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(w => w.length > 2));
+    const wordsA = new Set(a
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 2));
+    const wordsB = new Set(b
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 2));
     if (wordsA.size === 0 || wordsB.size === 0) {
         return 0;
     }
-    const intersection = new Set([...wordsA].filter(x => wordsB.has(x)));
+    const intersection = new Set([...wordsA].filter((x) => wordsB.has(x)));
     const union = new Set([...wordsA, ...wordsB]);
     return intersection.size / union.size;
 }
@@ -162,7 +183,7 @@ function similarity(a, b) {
  */
 export function smartMerge(original, corrupted) {
     const passingItems = extractPassingItems(corrupted);
-    const merged = original.map(entry => ({ ...entry })); // Deep copy
+    const merged = original.map((entry) => ({ ...entry })); // Deep copy
     let updated = 0;
     const warnings = [];
     for (const item of passingItems) {
@@ -173,7 +194,8 @@ export function smartMerge(original, corrupted) {
         let bestScore = 0;
         for (const entry of merged) {
             // Exact substring match
-            if (entry.description.includes(item.description) || item.description.includes(entry.description)) {
+            if (entry.description.includes(item.description) ||
+                item.description.includes(entry.description)) {
                 bestMatch = entry;
                 bestScore = 1;
                 break;
@@ -255,7 +277,7 @@ function attemptArrayRecovery(items) {
         const stepsFields = ["steps", "verification", "checks", "tasks"];
         for (const field of stepsFields) {
             if (Array.isArray(obj[field])) {
-                const steps = obj[field].filter(s => typeof s === "string");
+                const steps = obj[field].filter((s) => typeof s === "string");
                 if (steps.length > 0) {
                     entry.steps = steps;
                     break;
@@ -263,7 +285,16 @@ function attemptArrayRecovery(items) {
             }
         }
         // Passes mapping
-        const passesFields = ["passes", "pass", "passed", "done", "complete", "completed", "status", "finished"];
+        const passesFields = [
+            "passes",
+            "pass",
+            "passed",
+            "done",
+            "complete",
+            "completed",
+            "status",
+            "finished",
+        ];
         for (const field of passesFields) {
             const value = obj[field];
             if (typeof value === "boolean") {
@@ -272,11 +303,21 @@ function attemptArrayRecovery(items) {
             }
             if (typeof value === "string") {
                 const lower = value.toLowerCase();
-                if (lower === "true" || lower === "pass" || lower === "passed" || lower === "done" || lower === "complete" || lower === "completed" || lower === "finished") {
+                if (lower === "true" ||
+                    lower === "pass" ||
+                    lower === "passed" ||
+                    lower === "done" ||
+                    lower === "complete" ||
+                    lower === "completed" ||
+                    lower === "finished") {
                     entry.passes = true;
                     break;
                 }
-                if (lower === "false" || lower === "fail" || lower === "failed" || lower === "pending" || lower === "incomplete") {
+                if (lower === "false" ||
+                    lower === "fail" ||
+                    lower === "failed" ||
+                    lower === "pending" ||
+                    lower === "incomplete") {
                     entry.passes = false;
                     break;
                 }
@@ -320,7 +361,7 @@ export function findLatestBackup(prdPath) {
     }
     const files = readdirSync(dir);
     const backups = files
-        .filter(f => f.startsWith("backup.prd.") && f.endsWith(".json"))
+        .filter((f) => f.startsWith("backup.prd.") && f.endsWith(".json"))
         .sort()
         .reverse();
     if (backups.length === 0) {
@@ -343,10 +384,10 @@ export function createTemplatePrd(backupPath) {
                 description: "Fix the PRD entries",
                 steps: [
                     `Recreate PRD entries based on this corrupted backup content:\n\n@{${absolutePath}}`,
-                    "Write valid entries to .ralph/prd.json with format: category (string), description (string), steps (array of strings), passes (boolean)"
+                    "Write valid entries to .ralph/prd.json with format: category (string), description (string), steps (array of strings), passes (boolean)",
                 ],
                 passes: false,
-            }
+            },
         ];
     }
     return [
@@ -355,10 +396,10 @@ export function createTemplatePrd(backupPath) {
             description: "Add PRD entries",
             steps: [
                 "Add requirements using 'ralph add' or edit .ralph/prd.json directly",
-                "Verify format: category (string), description (string), steps (array of strings), passes (boolean)"
+                "Verify format: category (string), description (string), steps (array of strings), passes (boolean)",
             ],
             passes: false,
-        }
+        },
     ];
 }
 /**
@@ -409,9 +450,9 @@ export function expandFileReferences(text, baseDir) {
  * Returns a new array with expanded content.
  */
 export function expandPrdFileReferences(entries, baseDir) {
-    return entries.map(entry => ({
+    return entries.map((entry) => ({
         ...entry,
         description: expandFileReferences(entry.description, baseDir),
-        steps: entry.steps.map(step => expandFileReferences(step, baseDir)),
+        steps: entry.steps.map((step) => expandFileReferences(step, baseDir)),
     }));
 }

package/dist/utils/prompt.js

@@ -46,19 +46,23 @@ export async function promptSelectWithArrows(message, options) {
         process.stdin.setEncoding("utf8");
         const onKeypress = (key) => {
             // Handle arrow keys (escape sequences)
-            if (key === "\x1B[A" || key === "k") { // Up arrow or k
+            if (key === "\x1B[A" || key === "k") {
+                // Up arrow or k
                 selectedIndex = (selectedIndex - 1 + options.length) % options.length;
                 render();
             }
-            else if (key === "\x1B[B" || key === "j") { // Down arrow or j
+            else if (key === "\x1B[B" || key === "j") {
+                // Down arrow or j
                 selectedIndex = (selectedIndex + 1) % options.length;
                 render();
             }
-            else if (key === "\r" || key === "\n" || key === " ") { // Enter or space
+            else if (key === "\r" || key === "\n" || key === " ") {
+                // Enter or space
                 cleanup();
                 resolve(options[selectedIndex]);
             }
-            else if (key === "\x03") { // Ctrl+C
+            else if (key === "\x03") {
+                // Ctrl+C
                 cleanup();
                 process.exit(0);
             }
@@ -156,7 +160,8 @@ export async function promptMultiSelect(message, options) {
         }
         else {
             // Text input - treat as custom technology
-            if (!customTechs.includes(trimmed) && !selected.some(s => s.toLowerCase().includes(trimmed.toLowerCase()))) {
+            if (!customTechs.includes(trimmed) &&
+                !selected.some((s) => s.toLowerCase().includes(trimmed.toLowerCase()))) {
                 customTechs.push(trimmed);
                 console.log(`Added custom: ${trimmed}`);
             }
@@ -179,7 +184,7 @@ export async function promptMultiSelectWithArrows(message, options) {
             allOptions.forEach((opt, i) => {
                 const isLastOption = i === allOptions.length - 1;
                 const cursor = i === selectedIndex ? "\x1B[36m❯\x1B[0m" : " ";
-                const checkbox = isLastOption ? "" : (selected.has(i) ? "\x1B[32m[x]\x1B[0m" : "[ ]");
+                const checkbox = isLastOption ? "" : selected.has(i) ? "\x1B[32m[x]\x1B[0m" : "[ ]";
                 const text = i === selectedIndex ? `\x1B[36m${opt}\x1B[0m` : opt;
                 process.stdout.write(`\x1B[2K${cursor} ${checkbox} ${text}\n`);
             });
@@ -190,7 +195,7 @@ export async function promptMultiSelectWithArrows(message, options) {
             allOptions.forEach((opt, i) => {
                 const isLastOption = i === allOptions.length - 1;
                 const cursor = i === selectedIndex ? "\x1B[36m❯\x1B[0m" : " ";
-                const checkbox = isLastOption ? "" : (selected.has(i) ? "\x1B[32m[x]\x1B[0m" : "[ ]");
+                const checkbox = isLastOption ? "" : selected.has(i) ? "\x1B[32m[x]\x1B[0m" : "[ ]";
                 const text = i === selectedIndex ? `\x1B[36m${opt}\x1B[0m` : opt;
                 console.log(`${cursor} ${checkbox} ${text}`);
             });
@@ -202,15 +207,18 @@ export async function promptMultiSelectWithArrows(message, options) {
         process.stdin.resume();
         process.stdin.setEncoding("utf8");
         const onKeypress = (key) => {
-            if (key === "\x1B[A" || key === "k") { // Up
+            if (key === "\x1B[A" || key === "k") {
+                // Up
                 selectedIndex = (selectedIndex - 1 + allOptions.length) % allOptions.length;
                 render();
             }
-            else if (key === "\x1B[B" || key === "j") { // Down
+            else if (key === "\x1B[B" || key === "j") {
+                // Down
                 selectedIndex = (selectedIndex + 1) % allOptions.length;
                 render();
             }
-            else if (key === " ") { // Space - toggle selection
+            else if (key === " ") {
+                // Space - toggle selection
                 const isLastOption = selectedIndex === allOptions.length - 1;
                 if (!isLastOption) {
                     if (selected.has(selectedIndex)) {
@@ -222,12 +230,14 @@ export async function promptMultiSelectWithArrows(message, options) {
                     render();
                 }
             }
-            else if (key === "\r" || key === "\n") { // Enter - confirm
+            else if (key === "\r" || key === "\n") {
+                // Enter - confirm
                 cleanup();
                 const result = options.filter((_, i) => selected.has(i));
                 resolve(result);
             }
-            else if (key === "\x03") { // Ctrl+C
+            else if (key === "\x03") {
+                // Ctrl+C
                 cleanup();
                 process.exit(0);
             }

package/dist/utils/responder-logger.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Logger for responder calls.
+ * Logs LLM requests to .ralph/logs/ for debugging and auditing.
+ */
+/**
+ * Log entry for a responder call.
+ */
+export interface ResponderLogEntry {
+    timestamp: string;
+    responderName?: string;
+    responderType?: string;
+    trigger?: string;
+    gitCommand?: string;
+    gitDiffLength?: number;
+    filesRead?: string[];
+    filesNotFound?: string[];
+    filesTotalLength?: number;
+    threadContextLength?: number;
+    messageLength: number;
+    message: string;
+    systemPrompt?: string;
+}
+/**
+ * Log a responder call to the log file.
+ */
+export declare function logResponderCall(entry: ResponderLogEntry): void;
+/**
+ * Log a responder call to console (for debug mode).
+ */
+export declare function logResponderCallToConsole(entry: ResponderLogEntry): void;
+/**
+ * Create a log entry and optionally log to console.
+ */
+export declare function createResponderLog(options: {
+    responderName?: string;
+    responderType?: string;
+    trigger?: string;
+    gitCommand?: string;
+    gitDiffLength?: number;
+    filesRead?: string[];
+    filesNotFound?: string[];
+    filesTotalLength?: number;
+    threadContextLength?: number;
+    message: string;
+    systemPrompt?: string;
+    debug?: boolean;
+}): void;