ralph-cli-sandboxed 0.4.0 → 0.4.2

package/dist/utils/responder-logger.js

@@ -0,0 +1,129 @@
+/**
+ * Logger for responder calls.
+ * Logs LLM requests to .ralph/logs/ for debugging and auditing.
+ */
+import { mkdirSync, appendFileSync, existsSync } from "fs";
+import { join } from "path";
+/**
+ * Get the logs directory path (.ralph/logs).
+ */
+function getLogsDir() {
+    return join(process.cwd(), ".ralph", "logs");
+}
+/**
+ * Ensure the logs directory exists.
+ */
+function ensureLogsDir() {
+    const logsDir = getLogsDir();
+    if (!existsSync(logsDir)) {
+        mkdirSync(logsDir, { recursive: true });
+    }
+}
+/**
+ * Get today's log file path.
+ */
+function getLogFilePath() {
+    const date = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+    return join(getLogsDir(), `responder-${date}.log`);
+}
+/**
+ * Format a log entry for file output.
+ */
+function formatLogEntry(entry) {
+    const lines = [
+        ``,
+        `================================================================================`,
+        `[${entry.timestamp}] ${entry.responderName || "unknown"} (${entry.responderType || "unknown"})`,
+        `================================================================================`,
+    ];
+    if (entry.trigger) {
+        lines.push(`Trigger: ${entry.trigger}`);
+    }
+    if (entry.gitCommand) {
+        lines.push(`Git command: ${entry.gitCommand}`);
+        lines.push(`Git diff length: ${entry.gitDiffLength || 0} chars`);
+    }
+    if (entry.filesRead && entry.filesRead.length > 0) {
+        lines.push(`Files read: ${entry.filesRead.join(", ")}`);
+        lines.push(`Files total length: ${entry.filesTotalLength || 0} chars`);
+    }
+    if (entry.filesNotFound && entry.filesNotFound.length > 0) {
+        lines.push(`Files not found: ${entry.filesNotFound.join(", ")}`);
+    }
+    if (entry.threadContextLength) {
+        lines.push(`Thread context: ${entry.threadContextLength} chars`);
+    }
+    lines.push(`Message length: ${entry.messageLength} chars`);
+    lines.push(``);
+    if (entry.systemPrompt) {
+        lines.push(`--- System Prompt ---`);
+        lines.push(entry.systemPrompt);
+        lines.push(``);
+    }
+    lines.push(`--- Message to LLM ---`);
+    lines.push(entry.message);
+    lines.push(``);
+    return lines.join("\n");
+}
+/**
+ * Log a responder call to the log file.
+ */
+export function logResponderCall(entry) {
+    try {
+        ensureLogsDir();
+        const logFile = getLogFilePath();
+        const formatted = formatLogEntry(entry);
+        appendFileSync(logFile, formatted, "utf-8");
+    }
+    catch {
+        // Silently ignore logging errors to not disrupt the main flow
+    }
+}
+/**
+ * Log a responder call to console (for debug mode).
+ */
+export function logResponderCallToConsole(entry) {
+    console.log(`[responder] ${entry.responderName} (${entry.responderType})`);
+    if (entry.gitCommand) {
+        console.log(`[responder] Git command: ${entry.gitCommand}`);
+        console.log(`[responder] Git diff: ${entry.gitDiffLength || 0} chars`);
+    }
+    if (entry.filesRead && entry.filesRead.length > 0) {
+        console.log(`[responder] Files read: ${entry.filesRead.join(", ")}`);
+        console.log(`[responder] Files total: ${entry.filesTotalLength || 0} chars`);
+    }
+    if (entry.filesNotFound && entry.filesNotFound.length > 0) {
+        console.log(`[responder] Files not found: ${entry.filesNotFound.join(", ")}`);
+    }
+    if (entry.threadContextLength) {
+        console.log(`[responder] Thread context: ${entry.threadContextLength} chars`);
+    }
+    console.log(`[responder] Total message: ${entry.messageLength} chars`);
+    console.log(`[responder] Log file: ${getLogFilePath()}`);
+}
+/**
+ * Create a log entry and optionally log to console.
+ */
+export function createResponderLog(options) {
+    const entry = {
+        timestamp: new Date().toISOString(),
+        responderName: options.responderName,
+        responderType: options.responderType,
+        trigger: options.trigger,
+        gitCommand: options.gitCommand,
+        gitDiffLength: options.gitDiffLength,
+        filesRead: options.filesRead,
+        filesNotFound: options.filesNotFound,
+        filesTotalLength: options.filesTotalLength,
+        threadContextLength: options.threadContextLength,
+        messageLength: options.message.length,
+        message: options.message,
+        systemPrompt: options.systemPrompt,
+    };
+    // Always log to file
+    logResponderCall(entry);
+    // Log to console if debug mode
+    if (options.debug) {
+        logResponderCallToConsole(entry);
+    }
+}

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

@@ -0,0 +1,92 @@
+import { type ResponderConfig, type RespondersConfig } from "./config.js";
+/**
+ * Preset responder configuration from the JSON file.
+ */
+export interface ResponderPreset {
+    name: string;
+    description: string;
+    type: "llm" | "claude-code" | "cli";
+    trigger?: string;
+    provider?: string;
+    systemPrompt?: string;
+    command?: string;
+    timeout?: number;
+    maxLength?: number;
+}
+/**
+ * Bundle of presets for quick setup.
+ */
+export interface ResponderBundle {
+    name: string;
+    description: string;
+    presets: string[];
+}
+/**
+ * Full presets configuration from the JSON file.
+ */
+export interface ResponderPresetsConfig {
+    presets: Record<string, ResponderPreset>;
+    bundles: Record<string, ResponderBundle>;
+}
+/**
+ * Load responder presets from the configuration file.
+ */
+export declare function loadResponderPresets(): ResponderPresetsConfig;
+/**
+ * Get a single preset by ID.
+ */
+export declare function getResponderPreset(presetId: string): ResponderPreset | undefined;
+/**
+ * Get all available preset IDs.
+ */
+export declare function getResponderPresetIds(): string[];
+/**
+ * Get all available presets with their metadata.
+ */
+export declare function getResponderPresetList(): Array<{
+    id: string;
+} & ResponderPreset>;
+/**
+ * Get all available bundles.
+ */
+export declare function getResponderBundles(): Record<string, ResponderBundle>;
+/**
+ * Get a single bundle by ID.
+ */
+export declare function getResponderBundle(bundleId: string): ResponderBundle | undefined;
+/**
+ * Get all available bundle IDs.
+ */
+export declare function getResponderBundleIds(): string[];
+/**
+ * Convert a preset to a ResponderConfig for use in config.json.
+ * Strips the name and description fields that are only for display.
+ */
+export declare function presetToResponderConfig(preset: ResponderPreset): ResponderConfig;
+/**
+ * Convert multiple preset IDs to a RespondersConfig object.
+ * Uses the preset ID as the responder name.
+ */
+export declare function presetsToRespondersConfig(presetIds: string[]): RespondersConfig;
+/**
+ * Convert a bundle to a RespondersConfig object.
+ */
+export declare function bundleToRespondersConfig(bundleId: string): RespondersConfig;
+/**
+ * Get display options for preset selection in CLI prompts.
+ * Returns array of "name - description" strings for display.
+ */
+export declare function getPresetDisplayOptions(): string[];
+/**
+ * Get display options for bundle selection in CLI prompts.
+ * Returns array of "name - description (preset1, preset2, ...)" strings for display.
+ */
+export declare function getBundleDisplayOptions(): string[];
+/**
+ * Map bundle display option back to bundle ID.
+ */
+export declare function displayOptionToBundleId(displayOption: string): string | undefined;
+/**
+ * Map preset display option back to preset ID.
+ */
+export declare function displayOptionToPresetId(displayOption: string): string | undefined;

package/dist/utils/responder-presets.js

@@ -0,0 +1,156 @@
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Path to the presets file (relative to dist/utils when compiled)
+const PRESETS_FILE = join(__dirname, "..", "config", "responder-presets.json");
+/**
+ * Load responder presets from the configuration file.
+ */
+export function loadResponderPresets() {
+    try {
+        const content = readFileSync(PRESETS_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.error(`Failed to load responder presets: ${error}`);
+        return { presets: {}, bundles: {} };
+    }
+}
+/**
+ * Get a single preset by ID.
+ */
+export function getResponderPreset(presetId) {
+    const config = loadResponderPresets();
+    return config.presets[presetId];
+}
+/**
+ * Get all available preset IDs.
+ */
+export function getResponderPresetIds() {
+    const config = loadResponderPresets();
+    return Object.keys(config.presets);
+}
+/**
+ * Get all available presets with their metadata.
+ */
+export function getResponderPresetList() {
+    const config = loadResponderPresets();
+    return Object.entries(config.presets).map(([id, preset]) => ({
+        id,
+        ...preset,
+    }));
+}
+/**
+ * Get all available bundles.
+ */
+export function getResponderBundles() {
+    const config = loadResponderPresets();
+    return config.bundles;
+}
+/**
+ * Get a single bundle by ID.
+ */
+export function getResponderBundle(bundleId) {
+    const config = loadResponderPresets();
+    return config.bundles[bundleId];
+}
+/**
+ * Get all available bundle IDs.
+ */
+export function getResponderBundleIds() {
+    const config = loadResponderPresets();
+    return Object.keys(config.bundles);
+}
+/**
+ * Convert a preset to a ResponderConfig for use in config.json.
+ * Strips the name and description fields that are only for display.
+ */
+export function presetToResponderConfig(preset) {
+    const config = {
+        type: preset.type,
+    };
+    if (preset.trigger)
+        config.trigger = preset.trigger;
+    if (preset.provider)
+        config.provider = preset.provider;
+    if (preset.systemPrompt)
+        config.systemPrompt = preset.systemPrompt;
+    if (preset.command)
+        config.command = preset.command;
+    if (preset.timeout)
+        config.timeout = preset.timeout;
+    if (preset.maxLength)
+        config.maxLength = preset.maxLength;
+    return config;
+}
+/**
+ * Convert multiple preset IDs to a RespondersConfig object.
+ * Uses the preset ID as the responder name.
+ */
+export function presetsToRespondersConfig(presetIds) {
+    const config = loadResponderPresets();
+    const responders = {};
+    for (const id of presetIds) {
+        const preset = config.presets[id];
+        if (preset) {
+            responders[id] = presetToResponderConfig(preset);
+        }
+    }
+    return responders;
+}
+/**
+ * Convert a bundle to a RespondersConfig object.
+ */
+export function bundleToRespondersConfig(bundleId) {
+    const config = loadResponderPresets();
+    const bundle = config.bundles[bundleId];
+    if (!bundle) {
+        return {};
+    }
+    return presetsToRespondersConfig(bundle.presets);
+}
+/**
+ * Get display options for preset selection in CLI prompts.
+ * Returns array of "name - description" strings for display.
+ */
+export function getPresetDisplayOptions() {
+    const presets = getResponderPresetList();
+    return presets.map((p) => `${p.name} - ${p.description}`);
+}
+/**
+ * Get display options for bundle selection in CLI prompts.
+ * Returns array of "name - description (preset1, preset2, ...)" strings for display.
+ */
+export function getBundleDisplayOptions() {
+    const config = loadResponderPresets();
+    return Object.entries(config.bundles).map(([, bundle]) => {
+        const presetNames = bundle.presets.join(", ");
+        return `${bundle.name} - ${bundle.description} (${presetNames})`;
+    });
+}
+/**
+ * Map bundle display option back to bundle ID.
+ */
+export function displayOptionToBundleId(displayOption) {
+    const config = loadResponderPresets();
+    for (const [id, bundle] of Object.entries(config.bundles)) {
+        if (displayOption.startsWith(bundle.name)) {
+            return id;
+        }
+    }
+    return undefined;
+}
+/**
+ * Map preset display option back to preset ID.
+ */
+export function displayOptionToPresetId(displayOption) {
+    const config = loadResponderPresets();
+    for (const [id, preset] of Object.entries(config.presets)) {
+        if (displayOption.startsWith(preset.name)) {
+            return id;
+        }
+    }
+    return undefined;
+}

package/dist/utils/responder.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Responder matching and routing for chat messages.
+ * Matches incoming messages to configured responders based on trigger patterns.
+ */
+import { ResponderConfig, RespondersConfig } from "./config.js";
+/**
+ * Result of matching a message to a responder.
+ */
+export interface ResponderMatch {
+    /** The matched responder name (key in responders config) */
+    name: string;
+    /** The matched responder configuration */
+    responder: ResponderConfig;
+    /** The remaining message after removing the trigger (the arguments to pass to the responder) */
+    args: string;
+}
+/**
+ * ResponderMatcher handles routing chat messages to the appropriate responder
+ * based on configured trigger patterns.
+ *
+ * Trigger patterns:
+ * - "@name" triggers: Match when message starts with @name (e.g., "@qa", "@code", "@review")
+ * - "keyword" triggers: Match when message starts with the keyword (e.g., "!lint", "help")
+ * - No trigger (default): Matches any message that doesn't match other triggers
+ *
+ * The special "default" responder handles messages that don't match any trigger.
+ */
+export declare class ResponderMatcher {
+    private responders;
+    private mentionTriggers;
+    private keywordTriggers;
+    private defaultResponderName;
+    /**
+     * Create a new ResponderMatcher with the given responder configurations.
+     * @param responders The responders configuration (name -> config map)
+     */
+    constructor(responders: RespondersConfig);
+    /**
+     * Match a message to a responder based on trigger patterns.
+     *
+     * @param message The incoming message text
+     * @returns The matched responder and remaining args, or null if no match and no default
+     */
+    matchResponder(message: string): ResponderMatch | null;
+    /**
+     * Match @mention triggers in a message.
+     * First tries to match at the start of the message, then looks for triggers anywhere.
+     * Handles variations like "@qa", "@qa ", "@qa: ", etc.
+     */
+    private matchMentionTrigger;
+    /**
+     * Match keyword triggers at the start of a message.
+     */
+    private matchKeywordTrigger;
+    /**
+     * Extract the remaining message after a trigger, handling common separators.
+     */
+    private extractArgsAfterTrigger;
+    /**
+     * Get the default responder match, or null if no default is configured.
+     */
+    private getDefaultMatch;
+    /**
+     * Get all configured responder names.
+     */
+    getResponderNames(): string[];
+    /**
+     * Get a specific responder by name.
+     */
+    getResponder(name: string): ResponderConfig | undefined;
+    /**
+     * Check if a default responder is configured.
+     */
+    hasDefaultResponder(): boolean;
+    /**
+     * Get the default responder name if configured.
+     */
+    getDefaultResponderName(): string | null;
+}
+/**
+ * Convenience function to match a message against a responders config.
+ * Creates a ResponderMatcher and performs the match in one call.
+ *
+ * @param message The message to match
+ * @param responders The responders configuration
+ * @returns The match result or null
+ */
+export declare function matchResponder(message: string, responders: RespondersConfig): ResponderMatch | null;

package/dist/utils/responder.js

@@ -0,0 +1,207 @@
+/**
+ * Responder matching and routing for chat messages.
+ * Matches incoming messages to configured responders based on trigger patterns.
+ */
+/**
+ * ResponderMatcher handles routing chat messages to the appropriate responder
+ * based on configured trigger patterns.
+ *
+ * Trigger patterns:
+ * - "@name" triggers: Match when message starts with @name (e.g., "@qa", "@code", "@review")
+ * - "keyword" triggers: Match when message starts with the keyword (e.g., "!lint", "help")
+ * - No trigger (default): Matches any message that doesn't match other triggers
+ *
+ * The special "default" responder handles messages that don't match any trigger.
+ */
+export class ResponderMatcher {
+    responders;
+    mentionTriggers; // trigger -> responder name
+    keywordTriggers; // trigger -> responder name
+    defaultResponderName;
+    /**
+     * Create a new ResponderMatcher with the given responder configurations.
+     * @param responders The responders configuration (name -> config map)
+     */
+    constructor(responders) {
+        this.responders = new Map();
+        this.mentionTriggers = new Map();
+        this.keywordTriggers = new Map();
+        this.defaultResponderName = null;
+        // Process responders and categorize triggers
+        for (const [name, config] of Object.entries(responders)) {
+            this.responders.set(name, config);
+            // Check for default responder (no trigger or name is "default")
+            if (!config.trigger || name === "default") {
+                this.defaultResponderName = name;
+                continue;
+            }
+            const trigger = config.trigger.trim();
+            // @mention triggers (e.g., "@qa", "@code")
+            if (trigger.startsWith("@")) {
+                this.mentionTriggers.set(trigger.toLowerCase(), name);
+            }
+            else {
+                // Keyword triggers (e.g., "!lint", "help")
+                this.keywordTriggers.set(trigger.toLowerCase(), name);
+            }
+        }
+    }
+    /**
+     * Match a message to a responder based on trigger patterns.
+     *
+     * @param message The incoming message text
+     * @returns The matched responder and remaining args, or null if no match and no default
+     */
+    matchResponder(message) {
+        const trimmed = message.trim();
+        if (!trimmed) {
+            return this.getDefaultMatch("");
+        }
+        // Try to match @mention triggers first (highest priority)
+        const mentionMatch = this.matchMentionTrigger(trimmed);
+        if (mentionMatch) {
+            return mentionMatch;
+        }
+        // Try to match keyword triggers
+        const keywordMatch = this.matchKeywordTrigger(trimmed);
+        if (keywordMatch) {
+            return keywordMatch;
+        }
+        // Fall back to default responder
+        return this.getDefaultMatch(trimmed);
+    }
+    /**
+     * Match @mention triggers in a message.
+     * First tries to match at the start of the message, then looks for triggers anywhere.
+     * Handles variations like "@qa", "@qa ", "@qa: ", etc.
+     */
+    matchMentionTrigger(message) {
+        // First, try to match at the start of the message (highest priority)
+        if (message.startsWith("@")) {
+            const startMatch = message.match(/^(@\w+)/i);
+            if (startMatch) {
+                const mention = startMatch[1].toLowerCase();
+                const responderName = this.mentionTriggers.get(mention);
+                if (responderName) {
+                    const responder = this.responders.get(responderName);
+                    if (responder) {
+                        const args = this.extractArgsAfterTrigger(message, mention.length);
+                        return { name: responderName, responder, args };
+                    }
+                }
+            }
+        }
+        // If not at start, look for @trigger anywhere in the message
+        // This allows patterns like "need help @qa explain this"
+        for (const [trigger] of this.mentionTriggers) {
+            // Build regex to find trigger as a word boundary (not part of email, etc.)
+            // Match trigger preceded by whitespace or start, followed by whitespace, colon, or end
+            const escapedTrigger = trigger.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const regex = new RegExp(`(?:^|\\s)(${escapedTrigger})(?:[:\\s]|$)`, "i");
+            const match = message.match(regex);
+            if (match) {
+                const responderName = this.mentionTriggers.get(trigger);
+                if (!responderName)
+                    continue;
+                const responder = this.responders.get(responderName);
+                if (!responder)
+                    continue;
+                // Extract args: everything after the trigger
+                const triggerIndex = match.index + match[0].indexOf(match[1]);
+                const afterTrigger = message.slice(triggerIndex + match[1].length);
+                const args = afterTrigger.replace(/^[:]\s*/, "").replace(/^\s+/, "").trim();
+                return { name: responderName, responder, args };
+            }
+        }
+        return null;
+    }
+    /**
+     * Match keyword triggers at the start of a message.
+     */
+    matchKeywordTrigger(message) {
+        const lowerMessage = message.toLowerCase();
+        // Check each keyword trigger
+        for (const [trigger, responderName] of this.keywordTriggers) {
+            // Match if message starts with the trigger followed by whitespace or end of message
+            if (lowerMessage === trigger ||
+                lowerMessage.startsWith(trigger + " ") ||
+                lowerMessage.startsWith(trigger + ":") ||
+                lowerMessage.startsWith(trigger + "\n")) {
+                const responder = this.responders.get(responderName);
+                if (!responder) {
+                    continue;
+                }
+                const args = this.extractArgsAfterTrigger(message, trigger.length);
+                return {
+                    name: responderName,
+                    responder,
+                    args,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract the remaining message after a trigger, handling common separators.
+     */
+    extractArgsAfterTrigger(message, triggerLength) {
+        let remaining = message.slice(triggerLength);
+        // Remove leading separator if present (: or whitespace)
+        remaining = remaining.replace(/^[:]\s*/, "");
+        remaining = remaining.replace(/^\s+/, "");
+        return remaining.trim();
+    }
+    /**
+     * Get the default responder match, or null if no default is configured.
+     */
+    getDefaultMatch(args) {
+        if (!this.defaultResponderName) {
+            return null;
+        }
+        const responder = this.responders.get(this.defaultResponderName);
+        if (!responder) {
+            return null;
+        }
+        return {
+            name: this.defaultResponderName,
+            responder,
+            args,
+        };
+    }
+    /**
+     * Get all configured responder names.
+     */
+    getResponderNames() {
+        return Array.from(this.responders.keys());
+    }
+    /**
+     * Get a specific responder by name.
+     */
+    getResponder(name) {
+        return this.responders.get(name);
+    }
+    /**
+     * Check if a default responder is configured.
+     */
+    hasDefaultResponder() {
+        return this.defaultResponderName !== null;
+    }
+    /**
+     * Get the default responder name if configured.
+     */
+    getDefaultResponderName() {
+        return this.defaultResponderName;
+    }
+}
+/**
+ * Convenience function to match a message against a responders config.
+ * Creates a ResponderMatcher and performs the match in one call.
+ *
+ * @param message The message to match
+ * @param responders The responders configuration
+ * @returns The match result or null
+ */
+export function matchResponder(message, responders) {
+    const matcher = new ResponderMatcher(responders);
+    return matcher.matchResponder(message);
+}

package/dist/utils/stream-json.js

@@ -321,9 +321,10 @@ export class OpenCodeStreamParser extends BaseStreamParser {
                         let toolOutput = `\n── Tool: ${json.name || json.tool} ──\n`;
                         if (json.input || json.args || json.arguments) {
                             const toolInput = json.input || json.args || json.arguments;
-                            toolOutput += typeof toolInput === "string"
-                                ? toolInput + "\n"
-                                : JSON.stringify(toolInput, null, 2) + "\n";
+                            toolOutput +=
+                                typeof toolInput === "string"
+                                    ? toolInput + "\n"
+                                    : JSON.stringify(toolInput, null, 2) + "\n";
                         }
                         return toolOutput;
                     }
@@ -552,9 +553,8 @@ export class AiderStreamParser extends BaseStreamParser {
                         let toolOutput = `\n── Tool: ${json.name || json.function} ──\n`;
                         if (json.arguments || json.args) {
                             const args = json.arguments || json.args;
-                            toolOutput += typeof args === "string"
-                                ? args + "\n"
-                                : JSON.stringify(args, null, 2) + "\n";
+                            toolOutput +=
+                                typeof args === "string" ? args + "\n" : JSON.stringify(args, null, 2) + "\n";
                         }
                         return toolOutput;
                     }