ralph-cli-sandboxed 0.4.0 → 0.4.2

package/dist/commands/init.js

@@ -1,10 +1,11 @@
 import { existsSync, writeFileSync, mkdirSync, copyFileSync, chmodSync } from "fs";
 import { join, basename, dirname } from "path";
 import { fileURLToPath } from "url";
-import { getLanguages, generatePromptTemplate, DEFAULT_PRD, DEFAULT_PROGRESS, getCliProviders, getSkillsForLanguage } from "../templates/prompts.js";
-import { generateGenXcodeScript, hasSwiftUI, hasFastlane, generateFastfile, generateAppfile, generateFastlaneReadmeSection } from "../templates/macos-scripts.js";
-import { promptSelectWithArrows, promptConfirm, promptInput, promptMultiSelectWithArrows } from "../utils/prompt.js";
+import { getLanguages, generatePromptTemplate, DEFAULT_PRD, DEFAULT_PROGRESS, getCliProviders, getSkillsForLanguage, } from "../templates/prompts.js";
+import { generateGenXcodeScript, hasSwiftUI, hasFastlane, generateFastfile, generateAppfile, generateFastlaneReadmeSection, } from "../templates/macos-scripts.js";
+import { promptSelectWithArrows, promptConfirm, promptInput, promptMultiSelectWithArrows, } from "../utils/prompt.js";
 import { dockerInit } from "./docker.js";
+import { getBundleDisplayOptions, displayOptionToBundleId, bundleToRespondersConfig, getPresetDisplayOptions, displayOptionToPresetId, presetsToRespondersConfig, } from "../utils/responder-presets.js";
 // Get package root directory (works for both dev and installed package)
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -41,6 +42,7 @@ export async function init(args) {
     let selectedKey;
     let selectedTechnologies = [];
     let selectedSkills = [];
+    let selectedResponders = {};
     let checkCommand;
     let testCommand;
     if (useDefaults) {
@@ -62,7 +64,7 @@ export async function init(args) {
     else {
         // Step 1: Select CLI provider (first)
         const providerKeys = Object.keys(CLI_PROVIDERS);
-        const providerNames = providerKeys.map(k => `${CLI_PROVIDERS[k].name} - ${CLI_PROVIDERS[k].description}`);
+        const providerNames = providerKeys.map((k) => `${CLI_PROVIDERS[k].name} - ${CLI_PROVIDERS[k].description}`);
         const selectedProviderName = await promptSelectWithArrows("Select your AI CLI provider:", providerNames);
         const selectedProviderIndex = providerNames.indexOf(selectedProviderName);
         selectedCliProviderKey = providerKeys[selectedProviderIndex];
@@ -73,9 +75,13 @@ export async function init(args) {
             const customArgsInput = await promptInput("Enter default arguments (space-separated): ");
             const customArgs = customArgsInput.trim() ? customArgsInput.trim().split(/\s+/) : [];
             const customYoloArgsInput = await promptInput("Enter yolo/auto-approve arguments (space-separated): ");
-            const customYoloArgs = customYoloArgsInput.trim() ? customYoloArgsInput.trim().split(/\s+/) : [];
+            const customYoloArgs = customYoloArgsInput.trim()
+                ? customYoloArgsInput.trim().split(/\s+/)
+                : [];
             const customPromptArgsInput = await promptInput("Enter prompt arguments (e.g., -p for flag-based, leave empty for positional): ");
-            const customPromptArgs = customPromptArgsInput.trim() ? customPromptArgsInput.trim().split(/\s+/) : [];
+            const customPromptArgs = customPromptArgsInput.trim()
+                ? customPromptArgsInput.trim().split(/\s+/)
+                : [];
             cliConfig = {
                 command: customCommand || "claude",
                 args: customArgs,
@@ -94,7 +100,7 @@ export async function init(args) {
         console.log(`\nSelected CLI provider: ${CLI_PROVIDERS[selectedCliProviderKey].name}`);
         // Step 2: Select language (second)
         const languageKeys = Object.keys(LANGUAGES);
-        const languageNames = languageKeys.map(k => `${LANGUAGES[k].name} - ${LANGUAGES[k].description}`);
+        const languageNames = languageKeys.map((k) => `${LANGUAGES[k].name} - ${LANGUAGES[k].description}`);
         const selectedName = await promptSelectWithArrows("Select your project language/runtime:", languageNames);
         const selectedIndex = languageNames.indexOf(selectedName);
         selectedKey = languageKeys[selectedIndex];
@@ -102,11 +108,11 @@ export async function init(args) {
         console.log(`\nSelected language: ${config.name}`);
         // Step 3: Select technology stack if available (third)
         if (config.technologies && config.technologies.length > 0) {
-            const techOptions = config.technologies.map(t => `${t.name} - ${t.description}`);
-            const techNames = config.technologies.map(t => t.name);
+            const techOptions = config.technologies.map((t) => `${t.name} - ${t.description}`);
+            const techNames = config.technologies.map((t) => t.name);
             selectedTechnologies = await promptMultiSelectWithArrows("Select your technology stack (optional):", techOptions);
             // Convert display names back to just technology names for predefined options
-            selectedTechnologies = selectedTechnologies.map(sel => {
+            selectedTechnologies = selectedTechnologies.map((sel) => {
                 const idx = techOptions.indexOf(sel);
                 return idx >= 0 ? techNames[idx] : sel;
             });
@@ -120,10 +126,10 @@ export async function init(args) {
         // Step 4: Select skills if available for this language
         const availableSkills = getSkillsForLanguage(selectedKey);
         if (availableSkills.length > 0) {
-            const skillOptions = availableSkills.map(s => `${s.name} - ${s.description}`);
+            const skillOptions = availableSkills.map((s) => `${s.name} - ${s.description}`);
             const selectedSkillNames = await promptMultiSelectWithArrows("Select AI coding rules/skills to enable (optional):", skillOptions);
             // Convert selected display names to SkillConfig objects
-            selectedSkills = selectedSkillNames.map(sel => {
+            selectedSkills = selectedSkillNames.map((sel) => {
                 const idx = skillOptions.indexOf(sel);
                 const skill = availableSkills[idx];
                 return {
@@ -134,18 +140,52 @@ export async function init(args) {
                 };
             });
             if (selectedSkills.length > 0) {
-                console.log(`\nSelected skills: ${selectedSkills.map(s => s.name).join(", ")}`);
+                console.log(`\nSelected skills: ${selectedSkills.map((s) => s.name).join(", ")}`);
             }
             else {
                 console.log("\nNo skills selected.");
             }
         }
+        // Step 5: Select chat responder presets (optional)
+        const setupResponders = await promptConfirm("\nWould you like to set up chat responders?", false);
+        if (setupResponders) {
+            // First, ask if they want a bundle or individual presets
+            const selectionType = await promptSelectWithArrows("How would you like to configure responders?", [
+                "Use a preset bundle (recommended)",
+                "Select individual presets",
+                "Skip - configure later",
+            ]);
+            if (selectionType === "Use a preset bundle (recommended)") {
+                const bundleOptions = getBundleDisplayOptions();
+                const selectedBundle = await promptSelectWithArrows("Select a responder bundle:", bundleOptions);
+                const bundleId = displayOptionToBundleId(selectedBundle);
+                if (bundleId) {
+                    selectedResponders = bundleToRespondersConfig(bundleId);
+                    console.log(`\nConfigured responders from bundle: ${Object.keys(selectedResponders).join(", ")}`);
+                }
+            }
+            else if (selectionType === "Select individual presets") {
+                const presetOptions = getPresetDisplayOptions();
+                const selectedPresets = await promptMultiSelectWithArrows("Select responder presets to enable:", presetOptions);
+                // Convert display options back to preset IDs
+                const presetIds = selectedPresets
+                    .map(displayOptionToPresetId)
+                    .filter((id) => id !== undefined);
+                if (presetIds.length > 0) {
+                    selectedResponders = presetsToRespondersConfig(presetIds);
+                    console.log(`\nConfigured responders: ${Object.keys(selectedResponders).join(", ")}`);
+                }
+            }
+            else {
+                console.log("\nSkipping responders - you can configure them later in config.json");
+            }
+        }
         // Allow custom commands for "none" language
         checkCommand = config.checkCommand;
         testCommand = config.testCommand;
         if (selectedKey === "none") {
-            checkCommand = await promptInput("\nEnter your type/build check command: ") || checkCommand;
-            testCommand = await promptInput("Enter your test command: ") || testCommand;
+            checkCommand = (await promptInput("\nEnter your type/build check command: ")) || checkCommand;
+            testCommand = (await promptInput("Enter your test command: ")) || testCommand;
         }
     }
     const finalConfig = {
@@ -154,7 +194,9 @@ export async function init(args) {
         testCommand,
     };
     // Generate image name from directory name
-    const projectName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    const projectName = basename(cwd)
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-");
     const imageName = `ralph-${projectName}`;
     // Generate macOS development actions for Swift + SwiftUI projects
     const macOsActions = {};
@@ -197,6 +239,14 @@ export async function init(args) {
         // CLI configuration
         cli: cliConfig,
         cliProvider: selectedCliProviderKey,
+        // LLM providers for chat responders (empty by default, uses defaults from env vars)
+        // Example:
+        // llmProviders: {
+        //   "claude": { type: "anthropic", model: "claude-sonnet-4-20250514" },
+        //   "gpt4": { type: "openai", model: "gpt-4o" },
+        //   "local": { type: "ollama", model: "llama3", baseUrl: "http://localhost:11434" }
+        // }
+        llmProviders: {},
         // Optional fields with defaults/empty values for discoverability
         notifyCommand: "",
         technologies: selectedTechnologies.length > 0 ? selectedTechnologies : [],
@@ -244,6 +294,17 @@ export async function init(args) {
                 botToken: "",
                 allowedChatIds: [],
             },
+            // Chat responders - handle incoming messages based on triggers
+            // Special "default" responder handles messages that don't match any trigger
+            // Trigger patterns: "@name" for mentions, "keyword" for prefix matching
+            // Use "ralph init" to select from preset bundles, or configure manually:
+            // responders: {
+            //   "default": { type: "llm", provider: "anthropic", systemPrompt: "You are a helpful assistant for {{project}}." },
+            //   "qa": { type: "llm", trigger: "@qa", provider: "anthropic", systemPrompt: "Answer questions about the codebase." },
+            //   "code": { type: "claude-code", trigger: "@code" },
+            //   "lint": { type: "cli", trigger: "!lint", command: "npm run lint" }
+            // }
+            responders: selectedResponders,
         },
         // Daemon configuration for sandbox-to-host communication
         daemon: {
@@ -332,7 +393,7 @@ docker/.config-hash
         const swiftProjectName = basename(cwd)
             .replace(/[^a-zA-Z0-9]+/g, " ")
             .split(" ")
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
             .join("") || "App";
         if (!existsSync(genXcodePath)) {
             writeFileSync(genXcodePath, generateGenXcodeScript(swiftProjectName));

package/dist/commands/listen.js

@@ -3,9 +3,81 @@
  * This enables Telegram/chat commands to execute inside the container.
  */
 import { spawn } from "child_process";
-import { existsSync, watch } from "fs";
+import { existsSync, readFileSync, unlinkSync, watch } from "fs";
 import { isRunningInContainer } from "../utils/config.js";
 import { getMessagesPath, getPendingMessages, respondToMessage, cleanupOldMessages, } from "../utils/message-queue.js";
+const RUN_PID_FILE = "/workspace/.ralph/run.pid";
+/**
+ * Check if a ralph run process is currently running.
+ * Returns the PID if running, null otherwise.
+ */
+function getRunningPid() {
+    if (!existsSync(RUN_PID_FILE)) {
+        return null;
+    }
+    try {
+        const pid = parseInt(readFileSync(RUN_PID_FILE, "utf-8").trim(), 10);
+        if (isNaN(pid)) {
+            return null;
+        }
+        // Check if process is still alive
+        try {
+            process.kill(pid, 0); // Signal 0 just checks if process exists
+            return pid;
+        }
+        catch {
+            // Process doesn't exist, clean up stale PID file
+            try {
+                unlinkSync(RUN_PID_FILE);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Stop a running ralph run process by PID.
+ * Returns true if successfully stopped, false otherwise.
+ */
+function stopRunningProcess(pid) {
+    try {
+        // Kill the process group (negative PID) to also kill child processes (claude)
+        try {
+            process.kill(-pid, "SIGTERM");
+        }
+        catch {
+            // If process group kill fails, try killing just the process
+            process.kill(pid, "SIGTERM");
+        }
+        // Give it a moment to terminate gracefully
+        setTimeout(() => {
+            try {
+                // Check if still alive and force kill if necessary
+                process.kill(pid, 0);
+                process.kill(-pid, "SIGKILL");
+            }
+            catch {
+                // Already dead, good
+            }
+        }, 2000);
+        // Clean up PID file
+        try {
+            unlinkSync(RUN_PID_FILE);
+        }
+        catch {
+            // Ignore
+        }
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: `Failed to stop process: ${err}` };
+    }
+}
 /**
  * Execute a shell command and return the result.
  */
@@ -90,6 +162,16 @@ async function processMessage(message, messagesPath, debug) {
             break;
         }
         case "run": {
+            // Check if ralph run is already running
+            const existingPid = getRunningPid();
+            if (existingPid) {
+                console.log(`[listen] Ralph run already running (PID ${existingPid})`);
+                respondToMessage(messagesPath, message.id, {
+                    success: false,
+                    error: `Ralph run is already running (PID ${existingPid}). Use /stop to terminate it first.`,
+                });
+                return;
+            }
             // Start ralph run in background
             // Support optional category filter: run [category]
             const runArgs = ["run"];
@@ -108,10 +190,38 @@ async function processMessage(message, messagesPath, debug) {
             proc.unref();
             respondToMessage(messagesPath, message.id, {
                 success: true,
-                output: message.args?.length ? `Ralph run started (category: ${message.args[0]})` : "Ralph run started",
+                output: message.args?.length
+                    ? `Ralph run started (category: ${message.args[0]})`
+                    : "Ralph run started",
             });
             break;
         }
+        case "stop": {
+            // Stop a running ralph run process
+            const runningPid = getRunningPid();
+            if (!runningPid) {
+                respondToMessage(messagesPath, message.id, {
+                    success: true,
+                    output: "No ralph run process is currently running.",
+                });
+                return;
+            }
+            console.log(`[listen] Stopping ralph run (PID ${runningPid})...`);
+            const stopResult = stopRunningProcess(runningPid);
+            if (stopResult.success) {
+                respondToMessage(messagesPath, message.id, {
+                    success: true,
+                    output: `Stopped ralph run (PID ${runningPid})`,
+                });
+            }
+            else {
+                respondToMessage(messagesPath, message.id, {
+                    success: false,
+                    error: stopResult.error,
+                });
+            }
+            break;
+        }
         case "status": {
             // Get PRD status
             const result = await executeCommand("ralph status");
@@ -164,7 +274,7 @@ async function processMessage(message, messagesPath, debug) {
         default:
             respondToMessage(messagesPath, message.id, {
                 success: false,
-                error: `Unknown action: ${action}. Supported: exec, run, status, ping, claude`,
+                error: `Unknown action: ${action}. Supported: exec, run, stop, status, ping, claude`,
             });
     }
 }
@@ -179,7 +289,7 @@ async function startListening(debug) {
     console.log(`Messages file: ${messagesPath}`);
     console.log("");
     console.log("Listening for commands from host...");
-    console.log("Supported actions: exec, run, status, ping, claude");
+    console.log("Supported actions: exec, run, stop, status, ping, claude");
     console.log("");
     console.log("Press Ctrl+C to stop.");
     // Process any pending messages on startup
@@ -253,7 +363,8 @@ DESCRIPTION:
 
 SUPPORTED ACTIONS:
   exec [cmd]     Execute a shell command in the sandbox
-  run            Start ralph run
+  run            Start ralph run (fails if already running)
+  stop           Stop a running ralph run process
   status         Get PRD status
   ping           Health check
   claude [prompt] Run Claude Code with prompt (YOLO mode)

package/dist/commands/logo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hidden command to display the Ralph CLI ASCII art logo.
+ * Easter egg - not shown in help.
+ */
+export declare function logo(): Promise<void>;

package/dist/commands/logo.js

@@ -0,0 +1,41 @@
+/**
+ * Hidden command to display the Ralph CLI ASCII art logo.
+ * Easter egg - not shown in help.
+ */
+// Yellow gradient colors (Ralph Wiggum style)
+const GRADIENT = [
+    "\x1b[38;2;255;245;157m", // #FFF59D - pale yellow
+    "\x1b[38;2;255;238;88m", // #FFEE58 - light yellow
+    "\x1b[38;2;255;235;59m", // #FFEB3B - Simpsons yellow
+    "\x1b[38;2;253;216;53m", // #FDD835 - medium yellow
+    "\x1b[38;2;251;192;45m", // #FBC02D - golden yellow
+    "\x1b[38;2;249;168;37m", // #F9A825 - deep gold
+];
+const RESET = "\x1b[0m";
+const GRAY = "\x1b[38;5;248m";
+const LOGO_LINES = [
+    "██████╗  █████╗ ██╗     ██████╗ ██╗  ██╗     ██████╗██╗     ██╗",
+    "██╔══██╗██╔══██╗██║     ██╔══██╗██║  ██║    ██╔════╝██║     ██║",
+    "██████╔╝███████║██║     ██████╔╝███████║    ██║     ██║     ██║",
+    "██╔══██╗██╔══██║██║     ██╔═══╝ ██╔══██║    ██║     ██║     ██║",
+    "██║  ██║██║  ██║███████╗██║     ██║  ██║    ╚██████╗███████╗██║",
+    "╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═╝     ╚═╝  ╚═╝     ╚═════╝╚══════╝╚═╝",
+];
+export async function logo() {
+    console.log("");
+    for (let i = 0; i < LOGO_LINES.length; i++) {
+        const color = GRADIENT[i] || GRADIENT[GRADIENT.length - 1];
+        // Add "sandboxed" in yellow on line 3 (index 2)
+        const suffix = i === 2 ? `  ${GRADIENT[i]}sandboxed${RESET}` : "";
+        console.log(`${color}${LOGO_LINES[i]}${RESET}${suffix}`);
+    }
+    // Get version
+    try {
+        const pkg = await import("../../package.json", { with: { type: "json" } });
+        console.log(`${GRAY}v${pkg.default.version}${RESET}`);
+    }
+    catch {
+        console.log(`${GRAY}ralph-cli${RESET}`);
+    }
+    console.log("");
+}

package/dist/commands/notify.js

@@ -1,7 +1,7 @@
 import { isRunningInContainer } from "../utils/config.js";
 import { sendNotification } from "../utils/notification.js";
 import { loadConfig } from "../utils/config.js";
-import { getMessagesPath, sendMessage, waitForResponse, } from "../utils/message-queue.js";
+import { getMessagesPath, sendMessage, waitForResponse } from "../utils/message-queue.js";
 import { existsSync } from "fs";
 /**
  * Send a notification - works both inside and outside containers.

package/dist/commands/once.js

@@ -1,7 +1,7 @@
 import { spawn } from "child_process";
 import { existsSync, appendFileSync, mkdirSync } from "fs";
 import { join } from "path";
-import { checkFilesExist, loadConfig, loadPrompt, getPaths, getCliConfig, requireContainer } from "../utils/config.js";
+import { checkFilesExist, loadConfig, loadPrompt, getPaths, getCliConfig, requireContainer, } from "../utils/config.js";
 import { resolvePromptVariables, getCliProviders } from "../templates/prompts.js";
 import { getStreamJsonParser } from "../utils/stream-json.js";
 import { sendNotificationWithDaemonEvents } from "../utils/notification.js";
@@ -58,10 +58,7 @@ export async function once(args) {
     // Use yoloArgs from config if available, otherwise default to Claude's --dangerously-skip-permissions
     const yoloArgs = cliConfig.yoloArgs ?? ["--dangerously-skip-permissions"];
     const promptArgs = cliConfig.promptArgs ?? ["-p"];
-    const cliArgs = [
-        ...(cliConfig.args ?? []),
-        ...yoloArgs,
-    ];
+    const cliArgs = [...(cliConfig.args ?? []), ...yoloArgs];
     // Build the prompt value based on whether fileArgs is configured
     // fileArgs (e.g., ["--read"] for Aider) means files are passed as separate arguments
     // Otherwise, use @file syntax embedded in the prompt (Claude Code style)
@@ -98,7 +95,7 @@ export async function once(args) {
     }
     cliArgs.push(...promptArgs, promptValue);
     if (debug) {
-        console.log(`[debug] ${cliConfig.command} ${cliArgs.map(a => a.includes(" ") ? `"${a}"` : a).join(" ")}\n`);
+        console.log(`[debug] ${cliConfig.command} ${cliArgs.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ")}\n`);
         if (jsonLogPath) {
             console.log(`[debug] Saving raw JSON to: ${jsonLogPath}\n`);
         }
@@ -106,7 +103,12 @@ export async function once(args) {
     // Create provider-specific stream-json parser
     const streamJsonParser = getStreamJsonParser(config.cliProvider, debug);
     // Notification options for this run
-    const notifyOptions = { command: config.notifyCommand, debug, daemonConfig: config.daemon };
+    const notifyOptions = {
+        command: config.notifyCommand,
+        debug,
+        daemonConfig: config.daemon,
+        chatConfig: config.chat,
+    };
     return new Promise((resolve, reject) => {
         let output = ""; // Accumulate output for PRD complete detection
         if (streamJsonEnabled) {
@@ -180,7 +182,11 @@ export async function once(args) {
                 // Send notification based on outcome
                 if (code !== 0) {
                     console.error(`\n${cliConfig.command} exited with code ${code}`);
-                    await sendNotificationWithDaemonEvents("error", `Ralph: Iteration failed with exit code ${code}`, notifyOptions);
+                    const errorMessage = `Iteration failed with exit code ${code}`;
+                    await sendNotificationWithDaemonEvents("error", `Ralph: ${errorMessage}`, {
+                        ...notifyOptions,
+                        errorMessage,
+                    });
                 }
                 else if (output.includes("<promise>COMPLETE</promise>")) {
                     await sendNotificationWithDaemonEvents("prd_complete", undefined, notifyOptions);
@@ -208,7 +214,11 @@ export async function once(args) {
                 // Send notification based on outcome
                 if (code !== 0) {
                     console.error(`\n${cliConfig.command} exited with code ${code}`);
-                    await sendNotificationWithDaemonEvents("error", `Ralph: Iteration failed with exit code ${code}`, notifyOptions);
+                    const errorMessage = `Iteration failed with exit code ${code}`;
+                    await sendNotificationWithDaemonEvents("error", `Ralph: ${errorMessage}`, {
+                        ...notifyOptions,
+                        errorMessage,
+                    });
                 }
                 else if (output.includes("<promise>COMPLETE</promise>")) {
                     await sendNotificationWithDaemonEvents("prd_complete", undefined, notifyOptions);

package/dist/commands/prd.js

@@ -12,7 +12,22 @@ function loadPrd() {
     if (!existsSync(path)) {
         throw new Error(".ralph/prd.json not found. Run 'ralph init' first.");
     }
-    return JSON.parse(readFileSync(path, "utf-8"));
+    const content = readFileSync(path, "utf-8");
+    try {
+        return JSON.parse(content);
+    }
+    catch (err) {
+        const message = err instanceof SyntaxError ? err.message : "Invalid JSON";
+        console.error(`Error parsing .ralph/prd.json: ${message}`);
+        console.error("");
+        console.error("Common issues:");
+        console.error("  - Trailing comma before ] or }");
+        console.error("  - Missing comma between entries");
+        console.error("  - Unescaped quotes in strings");
+        console.error("");
+        console.error("Run 'ralph fix-prd' to attempt automatic repair.");
+        process.exit(1);
+    }
 }
 function savePrd(entries) {
     writeFileSync(getPrdPath(), JSON.stringify(entries, null, 2) + "\n");
@@ -219,7 +234,10 @@ export function parseListArgs(args) {
         else if (args[i] === "--passes" || args[i] === "--passed") {
             passesFilter = true;
         }
-        else if (args[i] === "--no-passes" || args[i] === "--no-passed" || args[i] === "--not-passed" || args[i] === "--not-passes") {
+        else if (args[i] === "--no-passes" ||
+            args[i] === "--no-passed" ||
+            args[i] === "--not-passed" ||
+            args[i] === "--not-passes") {
             passesFilter = false;
         }
     }