ralph-cli-sandboxed 0.3.0 → 0.4.0

package/dist/commands/fix-config.js

@@ -0,0 +1,388 @@
+import { existsSync, readFileSync, writeFileSync, copyFileSync } from "fs";
+import { getPaths } from "../utils/config.js";
+import { promptConfirm } from "../utils/prompt.js";
+import { getLanguages, getCliProviders } from "../templates/prompts.js";
+/**
+ * Configuration sections that can be individually validated and recovered.
+ */
+const CONFIG_SECTIONS = [
+    "language",
+    "checkCommand",
+    "testCommand",
+    "imageName",
+    "cli",
+    "cliProvider",
+    "notifyCommand",
+    "notifications",
+    "technologies",
+    "javaVersion",
+    "docker",
+    "claude",
+    "chat",
+    "daemon",
+];
+/**
+ * Attempts to parse JSON, returning the error position if parsing fails.
+ */
+function parseJsonWithError(content) {
+    try {
+        return { data: JSON.parse(content) };
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            const errorMsg = err.message;
+            // Extract position from error message (e.g., "at position 123" or "at line 5 column 10")
+            const posMatch = errorMsg.match(/at position (\d+)/);
+            const lineColMatch = errorMsg.match(/at line (\d+) column (\d+)/);
+            if (lineColMatch) {
+                return {
+                    error: errorMsg,
+                    line: parseInt(lineColMatch[1], 10),
+                    column: parseInt(lineColMatch[2], 10),
+                };
+            }
+            else if (posMatch) {
+                const position = parseInt(posMatch[1], 10);
+                const lines = content.substring(0, position).split("\n");
+                return {
+                    error: errorMsg,
+                    line: lines.length,
+                    column: lines[lines.length - 1].length + 1,
+                };
+            }
+            return { error: errorMsg };
+        }
+        return { error: String(err) };
+    }
+}
+/**
+ * Generates default config values (matching ralph init defaults).
+ */
+function getDefaultConfig() {
+    const LANGUAGES = getLanguages();
+    const CLI_PROVIDERS = getCliProviders();
+    const defaultLanguage = "node";
+    const defaultProvider = CLI_PROVIDERS["claude"];
+    const langConfig = LANGUAGES[defaultLanguage];
+    return {
+        language: defaultLanguage,
+        checkCommand: langConfig.checkCommand,
+        testCommand: langConfig.testCommand,
+        imageName: "ralph-project",
+        cli: {
+            command: defaultProvider.command,
+            args: defaultProvider.defaultArgs,
+            yoloArgs: defaultProvider.yoloArgs.length > 0 ? defaultProvider.yoloArgs : undefined,
+            promptArgs: defaultProvider.promptArgs ?? [],
+        },
+        cliProvider: "claude",
+        notifyCommand: "",
+        technologies: [],
+        docker: {
+            ports: [],
+            volumes: [],
+            environment: {},
+            git: {
+                name: "",
+                email: "",
+            },
+            packages: [],
+            buildCommands: {
+                root: [],
+                node: [],
+            },
+            startCommand: "",
+            asciinema: {
+                enabled: false,
+                autoRecord: false,
+                outputDir: ".recordings",
+                streamJson: {
+                    enabled: false,
+                    saveRawJson: true,
+                },
+            },
+            firewall: {
+                allowedDomains: [],
+            },
+            autoStart: false,
+            restartCount: 0,
+        },
+        claude: {
+            mcpServers: {},
+            skills: [],
+        },
+        chat: {
+            enabled: false,
+            provider: "telegram",
+            telegram: {
+                botToken: "",
+                allowedChatIds: [],
+            },
+        },
+        daemon: {
+            actions: {},
+            events: {},
+        },
+    };
+}
+/**
+ * Validates a specific section of the config.
+ */
+function validateSection(section, value) {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    switch (section) {
+        case "language":
+        case "checkCommand":
+        case "testCommand":
+        case "imageName":
+        case "cliProvider":
+        case "notifyCommand":
+            return typeof value === "string";
+        case "technologies":
+            return Array.isArray(value) && value.every((item) => typeof item === "string");
+        case "javaVersion":
+            return value === null || typeof value === "number";
+        case "cli":
+            if (typeof value !== "object" || value === null)
+                return false;
+            const cli = value;
+            return typeof cli.command === "string";
+        case "notifications":
+            if (typeof value !== "object" || value === null)
+                return false;
+            const notif = value;
+            return typeof notif.provider === "string";
+        case "docker":
+        case "claude":
+        case "chat":
+        case "daemon":
+            return typeof value === "object" && value !== null;
+        default:
+            return true;
+    }
+}
+/**
+ * Attempts to extract a value from potentially corrupt JSON using regex.
+ * This is a best-effort approach for partially corrupt files.
+ */
+function extractSectionFromCorrupt(content, section) {
+    // Try to find the section in the raw content
+    const patterns = {
+        language: /"language"\s*:\s*"([^"]+)"/,
+        checkCommand: /"checkCommand"\s*:\s*"([^"]+)"/,
+        testCommand: /"testCommand"\s*:\s*"([^"]+)"/,
+        imageName: /"imageName"\s*:\s*"([^"]+)"/,
+        cliProvider: /"cliProvider"\s*:\s*"([^"]+)"/,
+        notifyCommand: /"notifyCommand"\s*:\s*"([^"]*)"/,
+    };
+    const pattern = patterns[section];
+    if (pattern) {
+        const match = content.match(pattern);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+/**
+ * Attempts to recover valid sections from a corrupt config.
+ */
+function recoverSections(corruptContent, parsedPartial) {
+    const defaultConfig = getDefaultConfig();
+    const recoveredConfig = {};
+    const result = {
+        recovered: [],
+        reset: [],
+        errors: [],
+    };
+    for (const section of CONFIG_SECTIONS) {
+        let value = undefined;
+        let source = "default";
+        // First, try to get from parsed partial (if JSON was partially valid)
+        if (parsedPartial && section in parsedPartial) {
+            value = parsedPartial[section];
+            source = "parsed";
+        }
+        // If not found or invalid, try regex extraction for simple string fields
+        if ((value === undefined || !validateSection(section, value)) && typeof corruptContent === "string") {
+            const extracted = extractSectionFromCorrupt(corruptContent, section);
+            if (extracted !== undefined && validateSection(section, extracted)) {
+                value = extracted;
+                source = "extracted";
+            }
+        }
+        // Validate the value
+        if (validateSection(section, value)) {
+            recoveredConfig[section] = value;
+            result.recovered.push(section);
+        }
+        else {
+            // Use default value
+            recoveredConfig[section] = defaultConfig[section];
+            result.reset.push(section);
+        }
+    }
+    return result;
+}
+/**
+ * Creates a backup of the config file.
+ */
+function createBackup(configPath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = configPath.replace("config.json", `config.json.backup.${timestamp}`);
+    copyFileSync(configPath, backupPath);
+    return backupPath;
+}
+/**
+ * Merges recovered sections into a valid config object.
+ */
+function buildRecoveredConfig(corruptContent, parsedPartial) {
+    const defaultConfig = getDefaultConfig();
+    const result = {
+        recovered: [],
+        reset: [],
+        errors: [],
+    };
+    const config = {};
+    for (const section of CONFIG_SECTIONS) {
+        let value = undefined;
+        // First, try to get from parsed partial
+        if (parsedPartial && section in parsedPartial) {
+            value = parsedPartial[section];
+        }
+        // If not found or invalid, try regex extraction
+        if (value === undefined || !validateSection(section, value)) {
+            const extracted = extractSectionFromCorrupt(corruptContent, section);
+            if (extracted !== undefined && validateSection(section, extracted)) {
+                value = extracted;
+            }
+        }
+        // Validate and assign
+        if (validateSection(section, value)) {
+            config[section] = value;
+            result.recovered.push(section);
+        }
+        else {
+            config[section] = defaultConfig[section];
+            result.reset.push(section);
+        }
+    }
+    return { config: config, result };
+}
+/**
+ * Main fix-config command handler.
+ */
+export async function fixConfig(args) {
+    const verifyOnly = args.includes("--verify") || args.includes("-v");
+    const skipPrompt = args.includes("-y") || args.includes("--yes");
+    const paths = getPaths();
+    const configPath = paths.config;
+    // Check if config file exists
+    if (!existsSync(configPath)) {
+        console.error("Error: .ralph/config.json not found. Run 'ralph init' first.");
+        process.exit(1);
+    }
+    console.log("Checking config.json...\n");
+    // Read the raw content
+    const rawContent = readFileSync(configPath, "utf-8");
+    // Attempt to parse the JSON
+    const parseResult = parseJsonWithError(rawContent);
+    if (parseResult.data) {
+        // JSON is syntactically valid
+        const config = parseResult.data;
+        // Validate required fields
+        const missingFields = [];
+        if (typeof config.language !== "string")
+            missingFields.push("language");
+        if (typeof config.checkCommand !== "string")
+            missingFields.push("checkCommand");
+        if (typeof config.testCommand !== "string")
+            missingFields.push("testCommand");
+        if (missingFields.length === 0) {
+            console.log("\x1b[32m✓ config.json is valid.\x1b[0m");
+            return;
+        }
+        console.log("\x1b[33m⚠ config.json is missing required fields:\x1b[0m");
+        missingFields.forEach((field) => console.log(`  - ${field}`));
+        if (verifyOnly) {
+            process.exit(1);
+        }
+        // Offer to fix missing fields
+        if (!skipPrompt) {
+            const confirm = await promptConfirm("\nFix missing fields with defaults?");
+            if (!confirm) {
+                console.log("Aborted.");
+                return;
+            }
+        }
+        // Create backup
+        const backupPath = createBackup(configPath);
+        console.log(`\nCreated backup: ${backupPath}`);
+        // Merge with defaults
+        const defaultConfig = getDefaultConfig();
+        const fixedConfig = { ...defaultConfig, ...config };
+        // Ensure required fields exist
+        for (const field of missingFields) {
+            fixedConfig[field] = defaultConfig[field];
+        }
+        writeFileSync(configPath, JSON.stringify(fixedConfig, null, 2) + "\n");
+        console.log("\n\x1b[32m✓ config.json repaired.\x1b[0m");
+        console.log(`  Added defaults for: ${missingFields.join(", ")}`);
+        return;
+    }
+    // JSON parsing failed
+    console.log("\x1b[31m✗ config.json contains invalid JSON.\x1b[0m");
+    console.log(`  Error: ${parseResult.error}`);
+    if (parseResult.line) {
+        console.log(`  Location: line ${parseResult.line}, column ${parseResult.column || "?"}`);
+    }
+    if (verifyOnly) {
+        process.exit(1);
+    }
+    // Attempt recovery
+    console.log("\nAttempting to recover valid sections...\n");
+    // Try to parse partially (some JSON parsers are more lenient)
+    let parsedPartial = null;
+    try {
+        // Try JSON5-style parsing by removing trailing commas and comments
+        const cleaned = rawContent
+            .replace(/,\s*([\]}])/g, "$1") // Remove trailing commas
+            .replace(/\/\/.*$/gm, "") // Remove single-line comments
+            .replace(/\/\*[\s\S]*?\*\//g, ""); // Remove multi-line comments
+        parsedPartial = JSON.parse(cleaned);
+    }
+    catch {
+        // Partial parsing failed, continue with regex extraction
+    }
+    const { config: recoveredConfig, result } = buildRecoveredConfig(rawContent, parsedPartial);
+    // Report results
+    console.log("Recovery analysis:");
+    if (result.recovered.length > 0) {
+        console.log(`\x1b[32m  Recoverable sections (${result.recovered.length}):\x1b[0m`);
+        result.recovered.forEach((section) => console.log(`    ✓ ${section}`));
+    }
+    if (result.reset.length > 0) {
+        console.log(`\x1b[33m  Reset to defaults (${result.reset.length}):\x1b[0m`);
+        result.reset.forEach((section) => console.log(`    ⚠ ${section}`));
+    }
+    // Confirm before applying
+    if (!skipPrompt) {
+        console.log();
+        const confirm = await promptConfirm("Apply these fixes?");
+        if (!confirm) {
+            console.log("Aborted.");
+            return;
+        }
+    }
+    // Create backup of corrupt file
+    const backupPath = createBackup(configPath);
+    console.log(`\nCreated backup: ${backupPath}`);
+    // Write the recovered config
+    writeFileSync(configPath, JSON.stringify(recoveredConfig, null, 2) + "\n");
+    console.log("\n\x1b[32m✓ config.json repaired.\x1b[0m");
+    console.log(`  Recovered: ${result.recovered.length} sections`);
+    console.log(`  Reset to defaults: ${result.reset.length} sections`);
+    console.log(`  Original backup: ${backupPath}`);
+}

package/dist/commands/help.js

@@ -14,10 +14,12 @@ COMMANDS:
   toggle <n>        Toggle passes status for entry n
   clean             Remove all passing entries from the PRD
   fix-prd [opts]    Validate and recover corrupted PRD file
+  fix-config [opts] Validate and recover corrupted config.json
   prompt [opts]     Display resolved prompt (for testing in Claude Code)
   docker <sub>      Manage Docker sandbox environment
   daemon <sub>      Host daemon for sandbox-to-host communication
   notify [msg]      Send notification to host from sandbox
+  action [name]     Execute host actions from config.json
   chat <sub>        Chat client integration (Telegram, etc.)
   help              Show this help message
 
@@ -50,6 +52,10 @@ FIX-PRD OPTIONS:
   <backup-file>              Restore PRD from a specific backup file
   --verify, -v               Only verify format, don't attempt to fix
 
+FIX-CONFIG OPTIONS:
+  --verify, -v               Only verify format, don't attempt to fix
+  -y, --yes                  Skip confirmation prompt, apply fixes automatically
+
 DOCKER SUBCOMMANDS:
   docker init       Generate Dockerfile and scripts
   docker build      Build image (always fetches latest Claude Code)
@@ -74,6 +80,12 @@ NOTIFY OPTIONS:
   --action, -a <name>    Execute specific daemon action (default: notify)
   --debug, -d            Show debug output
 
+ACTION OPTIONS:
+  [name]                 Name of the action to execute
+  [args...]              Arguments to pass to the action command
+  --list, -l             List all configured actions
+  --debug, -d            Show debug output
+
 EXAMPLES:
   ralph init                 # Initialize ralph (interactive CLI, language, tech selection)
   ralph init -y              # Initialize with defaults (Claude + Node.js, no prompts)
@@ -95,6 +107,9 @@ EXAMPLES:
   ralph fix-prd              # Validate/recover corrupted PRD file
   ralph fix-prd --verify     # Check PRD format without fixing
   ralph fix-prd backup.prd.2024-01-15.json  # Restore from specific backup
+  ralph fix-config           # Validate/recover corrupted config.json
+  ralph fix-config --verify  # Check config format without fixing
+  ralph fix-config -y        # Auto-fix without prompts
   ralph prompt               # Display resolved prompt
   ralph docker init          # Generate Dockerfile for sandboxed env
   ralph docker build         # Build Docker image
@@ -103,6 +118,8 @@ EXAMPLES:
   ralph notify "Task done!"  # Send notification from sandbox to host
   ralph chat start           # Start Telegram chat daemon
   ralph chat test 123456     # Test chat connection
+  ralph action --list        # List available host actions
+  ralph action build         # Execute 'build' action on host
 
 CONFIGURATION:
   After running 'ralph init', you'll have:

package/dist/commands/init.js

@@ -1,7 +1,8 @@
-import { existsSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
+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 { dockerInit } from "./docker.js";
 // Get package root directory (works for both dev and installed package)
@@ -155,6 +156,37 @@ export async function init(args) {
     // Generate image name from directory name
     const projectName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
     const imageName = `ralph-${projectName}`;
+    // Generate macOS development actions for Swift + SwiftUI projects
+    const macOsActions = {};
+    if (selectedKey === "swift" && hasSwiftUI(selectedTechnologies)) {
+        macOsActions.gen_xcode = {
+            command: "./scripts/gen_xcode.sh",
+            description: "Generate Xcode project from Swift package",
+        };
+        macOsActions.build = {
+            command: "xcodebuild -project *.xcodeproj -scheme * -configuration Debug build",
+            description: "Build the Xcode project in Debug mode",
+        };
+        macOsActions.test = {
+            command: "xcodebuild -project *.xcodeproj -scheme * test",
+            description: "Run tests via xcodebuild",
+        };
+        // Add Fastlane actions if Fastlane technology is selected
+        if (hasFastlane(selectedTechnologies)) {
+            macOsActions.fastlane_init = {
+                command: "cd scripts/fastlane && fastlane init",
+                description: "Initialize Fastlane credentials (interactive)",
+            };
+            macOsActions.fastlane_beta = {
+                command: "cd scripts/fastlane && fastlane beta",
+                description: "Deploy beta build via Fastlane",
+            };
+            macOsActions.fastlane_release = {
+                command: "cd scripts/fastlane && fastlane release",
+                description: "Deploy release build via Fastlane",
+            };
+        }
+    }
     // Write config file with all available options (defaults or empty values)
     const configData = {
         // Required fields
@@ -215,7 +247,7 @@ export async function init(args) {
         },
         // Daemon configuration for sandbox-to-host communication
         daemon: {
-            actions: {},
+            actions: macOsActions,
             // Event handlers - each event can trigger multiple daemon actions
             // Available events: task_complete, ralph_complete, iteration_complete, error
             events: {
@@ -288,6 +320,61 @@ docker/.config-hash
     else {
         console.log(`Skipped ${RALPH_DIR}/.gitignore (already exists)`);
     }
+    // Generate macOS/Swift development scripts if Swift + SwiftUI selected
+    if (selectedKey === "swift" && hasSwiftUI(selectedTechnologies)) {
+        const scriptsDir = join(cwd, "scripts");
+        const genXcodePath = join(scriptsDir, "gen_xcode.sh");
+        if (!existsSync(scriptsDir)) {
+            mkdirSync(scriptsDir, { recursive: true });
+            console.log("Created scripts/");
+        }
+        // Use a clean project name (PascalCase) for the Swift project
+        const swiftProjectName = basename(cwd)
+            .replace(/[^a-zA-Z0-9]+/g, " ")
+            .split(" ")
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join("") || "App";
+        if (!existsSync(genXcodePath)) {
+            writeFileSync(genXcodePath, generateGenXcodeScript(swiftProjectName));
+            chmodSync(genXcodePath, 0o755);
+            console.log("Created scripts/gen_xcode.sh");
+        }
+        else {
+            console.log("Skipped scripts/gen_xcode.sh (already exists)");
+        }
+        // Generate Fastlane configuration if Fastlane technology is selected
+        if (hasFastlane(selectedTechnologies)) {
+            const fastlaneDir = join(scriptsDir, "fastlane");
+            const fastfilePath = join(fastlaneDir, "Fastfile");
+            const appfilePath = join(fastlaneDir, "Appfile");
+            const readmePath = join(fastlaneDir, "README.md");
+            if (!existsSync(fastlaneDir)) {
+                mkdirSync(fastlaneDir, { recursive: true });
+                console.log("Created scripts/fastlane/");
+            }
+            if (!existsSync(fastfilePath)) {
+                writeFileSync(fastfilePath, generateFastfile(swiftProjectName));
+                console.log("Created scripts/fastlane/Fastfile");
+            }
+            else {
+                console.log("Skipped scripts/fastlane/Fastfile (already exists)");
+            }
+            if (!existsSync(appfilePath)) {
+                writeFileSync(appfilePath, generateAppfile(swiftProjectName));
+                console.log("Created scripts/fastlane/Appfile");
+            }
+            else {
+                console.log("Skipped scripts/fastlane/Appfile (already exists)");
+            }
+            if (!existsSync(readmePath)) {
+                writeFileSync(readmePath, generateFastlaneReadmeSection(swiftProjectName));
+                console.log("Created scripts/fastlane/README.md");
+            }
+            else {
+                console.log("Skipped scripts/fastlane/README.md (already exists)");
+            }
+        }
+    }
     // Copy PRD guide file from package if not exists
     const prdGuidePath = join(ralphDir, PRD_GUIDE_FILE);
     if (!existsSync(prdGuidePath)) {

package/dist/commands/listen.js

@@ -91,8 +91,16 @@ async function processMessage(message, messagesPath, debug) {
         }
         case "run": {
             // Start ralph run in background
-            console.log("[listen] Starting ralph run...");
-            const proc = spawn("ralph", ["run"], {
+            // Support optional category filter: run [category]
+            const runArgs = ["run"];
+            if (message.args && message.args.length > 0) {
+                runArgs.push("--category", message.args[0]);
+                console.log(`[listen] Starting ralph run with category: ${message.args[0]}...`);
+            }
+            else {
+                console.log("[listen] Starting ralph run...");
+            }
+            const proc = spawn("ralph", runArgs, {
                 stdio: "inherit",
                 cwd: "/workspace",
                 detached: true,
@@ -100,7 +108,7 @@ async function processMessage(message, messagesPath, debug) {
             proc.unref();
             respondToMessage(messagesPath, message.id, {
                 success: true,
-                output: "Ralph run started",
+                output: message.args?.length ? `Ralph run started (category: ${message.args[0]})` : "Ralph run started",
             });
             break;
         }
@@ -121,10 +129,42 @@ async function processMessage(message, messagesPath, debug) {
             });
             break;
         }
+        case "claude": {
+            // Run Claude Code with the provided prompt in YOLO mode
+            const prompt = args?.join(" ") || "";
+            if (!prompt) {
+                respondToMessage(messagesPath, message.id, {
+                    success: false,
+                    error: "No prompt provided",
+                });
+                return;
+            }
+            console.log(`[listen] Running Claude Code with prompt: ${prompt.substring(0, 50)}...`);
+            // Build the command: claude -p "prompt" --dangerously-skip-permissions
+            // Using --print to get non-interactive output
+            const escapedPrompt = prompt.replace(/'/g, "'\\''");
+            const command = `claude -p '${escapedPrompt}' --dangerously-skip-permissions --print`;
+            // Run with 5 minute timeout
+            const result = await executeCommand(command, 300000);
+            // Truncate long output
+            let output = result.output;
+            if (output.length > 4000) {
+                output = output.substring(0, 4000) + "\n...(truncated)";
+            }
+            respondToMessage(messagesPath, message.id, {
+                success: result.success,
+                output,
+                error: result.error,
+            });
+            if (debug) {
+                console.log(`[listen] Claude Code result: ${result.success ? "OK" : "FAILED"}`);
+            }
+            break;
+        }
         default:
             respondToMessage(messagesPath, message.id, {
                 success: false,
-                error: `Unknown action: ${action}`,
+                error: `Unknown action: ${action}. Supported: exec, run, status, ping, claude`,
             });
     }
 }
@@ -139,7 +179,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");
+    console.log("Supported actions: exec, run, status, ping, claude");
     console.log("");
     console.log("Press Ctrl+C to stop.");
     // Process any pending messages on startup
@@ -212,10 +252,11 @@ DESCRIPTION:
   processes them and writes responses back.
 
 SUPPORTED ACTIONS:
-  exec [cmd]  Execute a shell command in the sandbox
-  run         Start ralph run
-  status      Get PRD status
-  ping        Health check
+  exec [cmd]     Execute a shell command in the sandbox
+  run            Start ralph run
+  status         Get PRD status
+  ping           Health check
+  claude [prompt] Run Claude Code with prompt (YOLO mode)
 
 SETUP:
   1. Start the daemon on the host: ralph daemon start

package/dist/commands/prd.js

@@ -91,8 +91,8 @@ export function prdList(category, passesFilter) {
         console.log("\nPRD Entries:\n");
     }
     filteredPrd.forEach(({ entry, originalIndex }) => {
-        const status = entry.passes ? "\x1b[32m[PASS]\x1b[0m" : "\x1b[33m[    ]\x1b[0m";
-        console.log(`  ${originalIndex + 1}. ${status} [${entry.category}] ${entry.description}`);
+        const statusEmoji = entry.passes ? "✅" : "○";
+        console.log(`  ${originalIndex + 1}. ${statusEmoji} [${entry.category}] ${entry.description}`);
         entry.steps.forEach((step, j) => {
             console.log(`       ${j + 1}. ${step}`);
         });

package/dist/config/languages.json

@@ -266,6 +266,10 @@
         { "name": "Hummingbird", "description": "Lightweight Swift web framework" },
         { "name": "Fluent ORM", "description": "Swift ORM for Vapor" },
         { "name": "SwiftNIO", "description": "Event-driven network framework" },
+        { "name": "SwiftUI", "description": "Apple declarative UI framework" },
+        { "name": "Fastlane", "description": "iOS/macOS deployment automation" },
+        { "name": "Combine", "description": "Reactive programming framework" },
+        { "name": "Swift Testing", "description": "Modern testing framework for Swift" },
         { "name": "XCTest", "description": "Swift testing framework" },
         { "name": "PostgreSQL", "description": "Advanced SQL database" },
         { "name": "SQLite", "description": "Embedded SQL database" },