ralph-cli-sandboxed 0.2.9 → 0.4.0

package/dist/commands/listen.js

@@ -0,0 +1,280 @@
+/**
+ * Listen command - runs in sandbox to process commands from host.
+ * This enables Telegram/chat commands to execute inside the container.
+ */
+import { spawn } from "child_process";
+import { existsSync, watch } from "fs";
+import { isRunningInContainer } from "../utils/config.js";
+import { getMessagesPath, getPendingMessages, respondToMessage, cleanupOldMessages, } from "../utils/message-queue.js";
+/**
+ * Execute a shell command and return the result.
+ */
+async function executeCommand(command, timeout = 60000) {
+    return new Promise((resolve) => {
+        const proc = spawn("sh", ["-c", command], {
+            stdio: ["ignore", "pipe", "pipe"],
+            cwd: "/workspace",
+        });
+        let stdout = "";
+        let stderr = "";
+        let killed = false;
+        const timer = setTimeout(() => {
+            killed = true;
+            proc.kill();
+            resolve({
+                success: false,
+                output: stdout,
+                error: "Command timed out after 60 seconds",
+            });
+        }, timeout);
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            if (killed)
+                return;
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve({ success: true, output: stdout.trim() || "(no output)" });
+            }
+            else {
+                resolve({
+                    success: false,
+                    output: stdout.trim(),
+                    error: stderr.trim() || `Exit code: ${code}`,
+                });
+            }
+        });
+        proc.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({ success: false, output: "", error: err.message });
+        });
+    });
+}
+/**
+ * Process a message from the host.
+ */
+async function processMessage(message, messagesPath, debug) {
+    const { action, args } = message;
+    if (debug) {
+        console.log(`[listen] Processing: ${action} ${args?.join(" ") || ""}`);
+    }
+    switch (action) {
+        case "exec": {
+            const command = args?.join(" ") || "";
+            if (!command) {
+                respondToMessage(messagesPath, message.id, {
+                    success: false,
+                    error: "No command provided",
+                });
+                return;
+            }
+            console.log(`[listen] Executing: ${command}`);
+            const result = await executeCommand(command);
+            // 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] Result: ${result.success ? "OK" : "FAILED"}`);
+            }
+            break;
+        }
+        case "run": {
+            // Start ralph run in background
+            // 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,
+            });
+            proc.unref();
+            respondToMessage(messagesPath, message.id, {
+                success: true,
+                output: message.args?.length ? `Ralph run started (category: ${message.args[0]})` : "Ralph run started",
+            });
+            break;
+        }
+        case "status": {
+            // Get PRD status
+            const result = await executeCommand("ralph status");
+            respondToMessage(messagesPath, message.id, {
+                success: result.success,
+                output: result.output,
+                error: result.error,
+            });
+            break;
+        }
+        case "ping": {
+            respondToMessage(messagesPath, message.id, {
+                success: true,
+                output: "pong from sandbox",
+            });
+            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}. Supported: exec, run, status, ping, claude`,
+            });
+    }
+}
+/**
+ * Start listening for messages from host.
+ */
+async function startListening(debug) {
+    const messagesPath = getMessagesPath(true); // true = in container
+    const ralphDir = "/workspace/.ralph";
+    console.log("Ralph Sandbox Listener");
+    console.log("-".repeat(40));
+    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("");
+    console.log("Press Ctrl+C to stop.");
+    // Process any pending messages on startup
+    const pending = getPendingMessages(messagesPath, "host");
+    for (const msg of pending) {
+        await processMessage(msg, messagesPath, debug);
+    }
+    // Watch for file changes
+    let processing = false;
+    let watcher = null;
+    const checkMessages = async () => {
+        if (processing)
+            return;
+        processing = true;
+        try {
+            const pending = getPendingMessages(messagesPath, "host");
+            for (const msg of pending) {
+                await processMessage(msg, messagesPath, debug);
+            }
+            // Cleanup old messages periodically
+            cleanupOldMessages(messagesPath, 300000); // 5 minutes
+        }
+        catch (err) {
+            if (debug) {
+                console.error(`[listen] Error: ${err}`);
+            }
+        }
+        processing = false;
+    };
+    // Watch the .ralph directory for changes
+    if (existsSync(ralphDir)) {
+        watcher = watch(ralphDir, { persistent: true }, (eventType, filename) => {
+            if (filename === "messages.json") {
+                checkMessages();
+            }
+        });
+    }
+    // Also poll periodically as backup
+    const pollInterval = setInterval(checkMessages, 1000);
+    // Handle shutdown
+    const shutdown = () => {
+        console.log("\nStopping listener...");
+        if (watcher) {
+            watcher.close();
+        }
+        clearInterval(pollInterval);
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+/**
+ * Main listen command handler.
+ */
+export async function listen(args) {
+    const debug = args.includes("--debug") || args.includes("-d");
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(`
+ralph listen - Listen for commands from host (run inside sandbox)
+
+USAGE:
+  ralph listen [--debug]  Start listening for host commands
+
+DESCRIPTION:
+  This command runs inside the sandbox container and listens for
+  commands sent from the host via the message queue. It enables
+  remote control of the sandbox via Telegram or other chat clients.
+
+  The host sends commands to .ralph/messages.json, and this listener
+  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
+  claude [prompt] Run Claude Code with prompt (YOLO mode)
+
+SETUP:
+  1. Start the daemon on the host: ralph daemon start
+  2. Start the chat client: ralph chat start
+  3. Inside the container, start the listener: ralph listen
+  4. Send commands via Telegram: /exec npm test
+
+EXAMPLE:
+  # Inside the container
+  ralph listen --debug
+`);
+        return;
+    }
+    // Warn if not in container (but allow for testing)
+    if (!isRunningInContainer()) {
+        console.warn("Warning: ralph listen is designed to run inside a container.");
+        console.warn("Running on host for testing purposes...");
+        console.warn("");
+    }
+    await startListening(debug);
+}

package/dist/commands/notify.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Send a notification - works both inside and outside containers.
+ *
+ * Inside container: Uses file-based message queue to communicate with host daemon
+ * Outside container: Uses notifyCommand directly (for testing)
+ */
+export declare function notify(args: string[]): Promise<void>;

package/dist/commands/notify.js

@@ -0,0 +1,165 @@
+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 { existsSync } from "fs";
+/**
+ * Send a notification - works both inside and outside containers.
+ *
+ * Inside container: Uses file-based message queue to communicate with host daemon
+ * Outside container: Uses notifyCommand directly (for testing)
+ */
+export async function notify(args) {
+    // Parse arguments
+    let action = "notify";
+    let message;
+    let debug = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--action" || arg === "-a") {
+            action = args[++i] || "notify";
+        }
+        else if (arg === "--debug" || arg === "-d") {
+            debug = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            showHelp();
+            return;
+        }
+        else if (!arg.startsWith("-")) {
+            // Collect remaining args as message
+            message = args.slice(i).join(" ");
+            break;
+        }
+    }
+    // Default message based on action
+    if (!message) {
+        if (action === "notify") {
+            message = "Ralph notification";
+        }
+    }
+    const inContainer = isRunningInContainer();
+    const messagesPath = getMessagesPath(inContainer);
+    if (debug) {
+        console.log(`[notify] Action: ${action}`);
+        console.log(`[notify] Message/Args: ${message || "(none)"}`);
+        console.log(`[notify] In container: ${inContainer}`);
+        console.log(`[notify] Messages file: ${messagesPath}`);
+    }
+    if (inContainer) {
+        // Inside container - use file-based message queue
+        if (!existsSync(messagesPath)) {
+            // Check if .ralph directory exists (mounted from host)
+            const ralphDir = "/workspace/.ralph";
+            if (!existsSync(ralphDir)) {
+                console.error("Error: .ralph directory not mounted in container.");
+                console.error("Make sure the container is started with 'ralph docker run'.");
+                process.exit(1);
+            }
+        }
+        // Send message via file queue
+        const messageId = sendMessage(messagesPath, "sandbox", action, message ? [message] : undefined);
+        if (debug) {
+            console.log(`[notify] Sent message: ${messageId}`);
+        }
+        console.log("Message sent. Waiting for daemon response...");
+        // Wait for response
+        const response = await waitForResponse(messagesPath, messageId, 10000);
+        if (!response) {
+            console.error("No response from daemon (timeout).");
+            console.error("");
+            console.error("Make sure the daemon is running on the host:");
+            console.error("  ralph daemon start");
+            process.exit(1);
+        }
+        if (debug) {
+            console.log(`[notify] Response: ${JSON.stringify(response)}`);
+        }
+        if (response.success) {
+            if (action === "ping") {
+                console.log("Daemon is responsive: pong");
+            }
+            else {
+                console.log("Notification sent successfully.");
+                if (response.output && debug) {
+                    console.log(`Output: ${response.output}`);
+                }
+            }
+        }
+        else {
+            console.error(`Failed: ${response.error}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Outside container - use direct notification or message queue
+        try {
+            const config = loadConfig();
+            if (config.notifyCommand) {
+                await sendNotification("iteration_complete", message, {
+                    command: config.notifyCommand,
+                    debug,
+                });
+                console.log("Notification sent directly.");
+            }
+            else {
+                console.error("No notifyCommand configured.");
+                console.error("Configure notifyCommand in .ralph/config.json");
+                process.exit(1);
+            }
+        }
+        catch {
+            console.error("Failed to load config. Run 'ralph init' first.");
+            process.exit(1);
+        }
+    }
+}
+function showHelp() {
+    console.log(`
+ralph notify - Send notification to host from sandbox
+
+USAGE:
+  ralph notify [message]              Send a notification message
+  ralph notify --action <action> [args...]  Execute a daemon action
+  ralph notify --help                 Show this help
+
+OPTIONS:
+  -a, --action <name>   Execute a specific daemon action (default: notify)
+  -d, --debug           Show debug output
+  -h, --help            Show this help message
+
+DESCRIPTION:
+  This command sends notifications or executes actions through the ralph
+  daemon. Communication happens via a shared file (.ralph/messages.json)
+  that is mounted into the container.
+
+EXAMPLES:
+  # Send a notification
+  ralph notify "Build complete!"
+  ralph notify "PRD task finished"
+
+  # Check daemon connectivity
+  ralph notify --action ping
+
+  # Execute custom action (if configured)
+  ralph notify --action custom-action arg1 arg2
+
+SETUP:
+  1. Configure notification command in .ralph/config.json:
+     { "notifyCommand": "ntfy pub mytopic" }
+
+  2. Start the daemon on the host:
+     ralph daemon start
+
+  3. Run the container:
+     ralph docker run
+
+  4. Send notifications from inside the container:
+     ralph notify "Hello from sandbox!"
+
+NOTES:
+  - The daemon must be running on the host to process messages
+  - Communication uses .ralph/messages.json (works on all platforms)
+  - Other tools can also read/write to this file for integration
+`);
+}

package/dist/commands/once.js

@@ -4,7 +4,7 @@ import { join } from "path";
 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 { sendNotification } from "../utils/notification.js";
+import { sendNotificationWithDaemonEvents } from "../utils/notification.js";
 export async function once(args) {
     // Parse flags
     let debug = false;
@@ -106,7 +106,7 @@ 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 };
+    const notifyOptions = { command: config.notifyCommand, debug, daemonConfig: config.daemon };
     return new Promise((resolve, reject) => {
         let output = ""; // Accumulate output for PRD complete detection
         if (streamJsonEnabled) {
@@ -180,13 +180,13 @@ export async function once(args) {
                 // Send notification based on outcome
                 if (code !== 0) {
                     console.error(`\n${cliConfig.command} exited with code ${code}`);
-                    await sendNotification("error", `Ralph: Iteration failed with exit code ${code}`, notifyOptions);
+                    await sendNotificationWithDaemonEvents("error", `Ralph: Iteration failed with exit code ${code}`, notifyOptions);
                 }
                 else if (output.includes("<promise>COMPLETE</promise>")) {
-                    await sendNotification("prd_complete", undefined, notifyOptions);
+                    await sendNotificationWithDaemonEvents("prd_complete", undefined, notifyOptions);
                 }
                 else {
-                    await sendNotification("iteration_complete", undefined, notifyOptions);
+                    await sendNotificationWithDaemonEvents("iteration_complete", undefined, notifyOptions);
                 }
                 resolve();
             });
@@ -208,13 +208,13 @@ export async function once(args) {
                 // Send notification based on outcome
                 if (code !== 0) {
                     console.error(`\n${cliConfig.command} exited with code ${code}`);
-                    await sendNotification("error", `Ralph: Iteration failed with exit code ${code}`, notifyOptions);
+                    await sendNotificationWithDaemonEvents("error", `Ralph: Iteration failed with exit code ${code}`, notifyOptions);
                 }
                 else if (output.includes("<promise>COMPLETE</promise>")) {
-                    await sendNotification("prd_complete", undefined, notifyOptions);
+                    await sendNotificationWithDaemonEvents("prd_complete", undefined, notifyOptions);
                 }
                 else {
-                    await sendNotification("iteration_complete", undefined, notifyOptions);
+                    await sendNotificationWithDaemonEvents("iteration_complete", undefined, notifyOptions);
                 }
                 resolve();
             });

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/commands/run.js

@@ -5,7 +5,7 @@ import { checkFilesExist, loadConfig, loadPrompt, getPaths, getCliConfig, requir
 import { resolvePromptVariables, getCliProviders } from "../templates/prompts.js";
 import { validatePrd, smartMerge, readPrdFile, writePrd, expandPrdFileReferences } from "../utils/prd-validator.js";
 import { getStreamJsonParser } from "../utils/stream-json.js";
-import { sendNotification } from "../utils/notification.js";
+import { sendNotificationWithDaemonEvents } from "../utils/notification.js";
 const CATEGORIES = ["ui", "feature", "bugfix", "setup", "development", "testing", "docs"];
 /**
  * Creates a filtered PRD file containing only incomplete items (passes: false).
@@ -51,19 +51,19 @@ function createFilteredPrd(prdPath, baseDir, category) {
  * Syncs passes flags from prd-tasks.json back to prd.json.
  * If the LLM marked any item as passes: true in prd-tasks.json,
  * find the matching item in prd.json and update it.
- * Returns the number of items synced.
+ * Returns the number of items synced and their names.
  */
 function syncPassesFromTasks(tasksPath, prdPath) {
     // Check if tasks file exists
     if (!existsSync(tasksPath)) {
-        return 0;
+        return { count: 0, taskNames: [] };
     }
     try {
         const tasksContent = readFileSync(tasksPath, "utf-8");
         const tasksParsed = JSON.parse(tasksContent);
         if (!Array.isArray(tasksParsed)) {
             console.warn("\x1b[33mWarning: prd-tasks.json is not a valid array - skipping sync.\x1b[0m");
-            return 0;
+            return { count: 0, taskNames: [] };
         }
         const tasks = tasksParsed;
         const prdContent = readFileSync(prdPath, "utf-8");
@@ -71,10 +71,11 @@ function syncPassesFromTasks(tasksPath, prdPath) {
         if (!Array.isArray(prdParsed)) {
             console.warn("\x1b[33mWarning: prd.json is corrupted - skipping sync.\x1b[0m");
             console.warn("Run \x1b[36mralph fix-prd\x1b[0m after this session to repair.\n");
-            return 0;
+            return { count: 0, taskNames: [] };
         }
         const prd = prdParsed;
         let synced = 0;
+        const syncedTaskNames = [];
         // Find tasks that were marked as passing
         for (const task of tasks) {
             if (task.passes === true) {
@@ -85,6 +86,7 @@ function syncPassesFromTasks(tasksPath, prdPath) {
                 if (match && !match.passes) {
                     match.passes = true;
                     synced++;
+                    syncedTaskNames.push(task.description);
                 }
             }
         }
@@ -93,11 +95,11 @@ function syncPassesFromTasks(tasksPath, prdPath) {
             writeFileSync(prdPath, JSON.stringify(prd, null, 2) + "\n");
             console.log(`\x1b[32mSynced ${synced} completed item(s) from prd-tasks.json to prd.json\x1b[0m`);
         }
-        return synced;
+        return { count: synced, taskNames: syncedTaskNames };
     }
     catch {
         // Ignore errors - the validation step will handle any issues
-        return 0;
+        return { count: 0, taskNames: [] };
     }
 }
 async function runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig, debug, model, streamJson) {
@@ -544,9 +546,10 @@ export async function run(args) {
                     }
                     console.log("=".repeat(50));
                     // Send notification for PRD completion
-                    await sendNotification("prd_complete", undefined, {
+                    await sendNotificationWithDaemonEvents("prd_complete", undefined, {
                         command: config.notifyCommand,
                         debug,
+                        daemonConfig: config.daemon,
                     });
                     break;
                 }
@@ -554,7 +557,16 @@ export async function run(args) {
             const { exitCode, output } = await runIteration(prompt, paths, sandboxed, filteredPrdPath, cliConfig, debug, model, streamJson);
             // Sync any completed items from prd-tasks.json back to prd.json
             // This catches cases where the LLM updated prd-tasks.json instead of prd.json
-            syncPassesFromTasks(filteredPrdPath, paths.prd);
+            const syncResult = syncPassesFromTasks(filteredPrdPath, paths.prd);
+            // Send task_complete notification for each completed task
+            for (const taskName of syncResult.taskNames) {
+                await sendNotificationWithDaemonEvents("task_complete", `Ralph: Task complete - ${taskName}`, {
+                    command: config.notifyCommand,
+                    debug,
+                    daemonConfig: config.daemon,
+                    taskName,
+                });
+            }
             // Clean up temp file after each iteration
             try {
                 unlinkSync(filteredPrdPath);
@@ -586,7 +598,7 @@ export async function run(args) {
                     console.log(`Status: ${progressCounts.complete}/${progressCounts.total} complete, ${progressCounts.incomplete} remaining.`);
                     console.log("Check the PRD and task definitions for issues.");
                     // Send notification about stopped run
-                    await sendNotification("run_stopped", `Ralph: Run stopped - no progress after ${MAX_ITERATIONS_WITHOUT_PROGRESS} iterations. ${progressCounts.incomplete} tasks remaining.`, { command: config.notifyCommand, debug });
+                    await sendNotificationWithDaemonEvents("run_stopped", `Ralph: Run stopped - no progress after ${MAX_ITERATIONS_WITHOUT_PROGRESS} iterations. ${progressCounts.incomplete} tasks remaining.`, { command: config.notifyCommand, debug, daemonConfig: config.daemon });
                     break;
                 }
             }
@@ -605,7 +617,7 @@ export async function run(args) {
                     console.error("This usually indicates a configuration error (e.g., missing API key).");
                     console.error("Please check your CLI configuration and try again.");
                     // Send notification about error
-                    await sendNotification("error", `Ralph: CLI failed ${consecutiveFailures} times with exit code ${exitCode}. Check configuration.`, { command: config.notifyCommand, debug });
+                    await sendNotificationWithDaemonEvents("error", `Ralph: CLI failed ${consecutiveFailures} times with exit code ${exitCode}. Check configuration.`, { command: config.notifyCommand, debug, daemonConfig: config.daemon });
                     break;
                 }
                 console.log("Continuing to next iteration...");
@@ -646,9 +658,10 @@ export async function run(args) {
                     }
                     console.log("=".repeat(50));
                     // Send notification if configured
-                    await sendNotification("prd_complete", undefined, {
+                    await sendNotificationWithDaemonEvents("prd_complete", undefined, {
                         command: config.notifyCommand,
                         debug,
+                        daemonConfig: config.daemon,
                     });
                     break;
                 }

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" },