ralph-cli-sandboxed 0.4.2 → 0.5.0

package/dist/commands/prd.js

@@ -1,36 +1,109 @@
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { promptInput, promptSelect } from "../utils/prompt.js";
-import { getRalphDir } from "../utils/config.js";
-const PRD_FILE = "prd.json";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { extname, join } from "path";
+import { promptInput, promptSelect, promptConfirm } from "../utils/prompt.js";
+import { getRalphDir, getPrdFiles } from "../utils/config.js";
+import { convert as prdConvert } from "./prd-convert.js";
+import { DEFAULT_PRD_YAML } from "../templates/prompts.js";
+import YAML from "yaml";
+const PRD_FILE_JSON = "prd.json";
+const PRD_FILE_YAML = "prd.yaml";
 const CATEGORIES = ["ui", "feature", "bugfix", "setup", "development", "testing", "docs"];
+// Track whether we've shown the migration notice in this session
+let migrationNoticeShown = false;
 function getPrdPath() {
-    return join(getRalphDir(), PRD_FILE);
-}
-function loadPrd() {
-    const path = getPrdPath();
-    if (!existsSync(path)) {
-        throw new Error(".ralph/prd.json not found. Run 'ralph init' first.");
+    const prdFiles = getPrdFiles();
+    if (prdFiles.primary) {
+        return prdFiles.primary;
     }
+    // Fallback to json path for backwards compatibility
+    return join(getRalphDir(), PRD_FILE_JSON);
+}
+/**
+ * Parses a PRD file based on its extension.
+ * Supports both JSON and YAML formats.
+ * Returns empty array if file is empty or parses to null.
+ */
+function parsePrdFile(path) {
     const content = readFileSync(path, "utf-8");
+    const ext = extname(path).toLowerCase();
     try {
-        return JSON.parse(content);
+        let result;
+        if (ext === ".yaml" || ext === ".yml") {
+            result = YAML.parse(content);
+        }
+        else {
+            result = JSON.parse(content);
+        }
+        // Handle empty files or null content
+        return result ?? [];
     }
     catch (err) {
-        const message = err instanceof SyntaxError ? err.message : "Invalid JSON";
-        console.error(`Error parsing .ralph/prd.json: ${message}`);
+        const format = ext === ".yaml" || ext === ".yml" ? "YAML" : "JSON";
+        const message = err instanceof Error ? err.message : `Invalid ${format}`;
+        console.error(`Error parsing ${path}: ${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");
+        if (format === "JSON") {
+            console.error("  - Trailing comma before ] or }");
+            console.error("  - Missing comma between entries");
+            console.error("  - Unescaped quotes in strings");
+        }
+        else {
+            console.error("  - Incorrect indentation");
+            console.error("  - Missing colons after keys");
+            console.error("  - Unquoted special characters");
+        }
         console.error("");
         console.error("Run 'ralph fix-prd' to attempt automatic repair.");
         process.exit(1);
     }
 }
+/**
+ * Loads PRD entries from prd.yaml and/or prd.json.
+ * - If neither exists, creates prd.yaml with default content
+ * - If both exist, merges them (no deduplication)
+ * - If only prd.json exists, shows migration notice
+ * - If only prd.yaml exists, uses it (happy path)
+ */
+function loadPrd() {
+    const prdFiles = getPrdFiles();
+    if (prdFiles.none) {
+        // Create .ralph directory if it doesn't exist
+        const ralphDir = getRalphDir();
+        if (!existsSync(ralphDir)) {
+            mkdirSync(ralphDir, { recursive: true });
+        }
+        // Create default prd.yaml
+        const prdPath = join(ralphDir, PRD_FILE_YAML);
+        writeFileSync(prdPath, DEFAULT_PRD_YAML);
+        console.log(`Created ${prdPath}`);
+        return parsePrdFile(prdPath);
+    }
+    // If only JSON exists, show migration notice (once per session)
+    if (prdFiles.jsonOnly && !migrationNoticeShown) {
+        console.log("\x1b[33mNote: Consider migrating to YAML format with 'ralph prd convert'\x1b[0m");
+        console.log("");
+        migrationNoticeShown = true;
+    }
+    // Load primary file
+    const primary = parsePrdFile(prdFiles.primary);
+    // If both files exist, merge them
+    if (prdFiles.both && prdFiles.secondary) {
+        const secondary = parsePrdFile(prdFiles.secondary);
+        // Merge without deduplication - primary (YAML) first, then secondary (JSON)
+        return [...primary, ...secondary];
+    }
+    return primary;
+}
 function savePrd(entries) {
-    writeFileSync(getPrdPath(), JSON.stringify(entries, null, 2) + "\n");
+    const path = getPrdPath();
+    const ext = extname(path).toLowerCase();
+    if (ext === ".yaml" || ext === ".yml") {
+        writeFileSync(path, YAML.stringify(entries));
+    }
+    else {
+        writeFileSync(path, JSON.stringify(entries, null, 2) + "\n");
+    }
 }
 export async function prdAdd() {
     console.log("Add new PRD entry\n");
@@ -114,7 +187,7 @@ export function prdList(category, passesFilter) {
         console.log();
     });
 }
-export function prdStatus() {
+export function prdStatus(headOnly = false) {
     const prd = loadPrd();
     if (prd.length === 0) {
         console.log("No PRD entries found.");
@@ -146,7 +219,7 @@ export function prdStatus() {
     if (passing === total) {
         console.log("\n  \x1b[32m\u2713 All requirements complete!\x1b[0m");
     }
-    else {
+    else if (!headOnly) {
         const remaining = prd.filter((e) => !e.passes);
         console.log(`\n  Remaining (${remaining.length}):`);
         remaining.forEach((entry) => {
@@ -154,6 +227,71 @@ export function prdStatus() {
         });
     }
 }
+/**
+ * Parses a range string like "1-18" into an array of numbers [1, 2, ..., 18].
+ * Returns null if the string is not a valid range.
+ */
+function parseRange(str) {
+    const match = str.match(/^(\d+)-(\d+)$/);
+    if (!match)
+        return null;
+    const start = parseInt(match[1]);
+    const end = parseInt(match[2]);
+    if (isNaN(start) || isNaN(end) || start < 1 || end < 1)
+        return null;
+    if (start > end)
+        return null;
+    const result = [];
+    for (let i = start; i <= end; i++) {
+        result.push(i);
+    }
+    return result;
+}
+/**
+ * Expands arguments to handle range syntax.
+ * Supports:
+ * - "1-18" (single arg with dash) → [1, 2, ..., 18]
+ * - "1", "-", "18" (three args with dash separator) → [1, 2, ..., 18]
+ * - "1", "18" (separate numbers) → [1, 18]
+ */
+function expandRangeArgs(args) {
+    const indices = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        // Check if this arg is a range like "1-18"
+        const range = parseRange(arg);
+        if (range) {
+            indices.push(...range);
+            continue;
+        }
+        // Check if this is part of a "start - end" pattern (with spaces)
+        if (arg === "-" && i > 0 && i + 1 < args.length) {
+            // Look back to see if previous was a number and forward to see if next is a number
+            const prevNum = parseInt(args[i - 1]);
+            const nextNum = parseInt(args[i + 1]);
+            if (!isNaN(prevNum) && !isNaN(nextNum) && prevNum >= 1 && nextNum >= 1) {
+                // Remove the previous number we already added (it's the start of a range)
+                indices.pop();
+                if (prevNum > nextNum) {
+                    return null; // Invalid range
+                }
+                // Add the full range
+                for (let j = prevNum; j <= nextNum; j++) {
+                    indices.push(j);
+                }
+                i++; // Skip the next number since we already processed it
+                continue;
+            }
+        }
+        // Otherwise, parse as a single number
+        const num = parseInt(arg);
+        if (isNaN(num) || num < 1) {
+            return null; // Invalid argument
+        }
+        indices.push(num);
+    }
+    return indices.length > 0 ? indices : null;
+}
 export function prdToggle(args) {
     const arg = args[0];
     // Check for --all flag
@@ -170,19 +308,11 @@ export function prdToggle(args) {
         console.log(`Toggled all ${prd.length} PRD entries.`);
         return;
     }
-    // Parse all numeric arguments
-    const indices = [];
-    for (const a of args) {
-        const index = parseInt(a);
-        if (!index || isNaN(index)) {
-            console.error("Usage: ralph prd toggle <number> [number2] [number3] ...");
-            console.error("       ralph prd toggle --all");
-            process.exit(1);
-        }
-        indices.push(index);
-    }
-    if (indices.length === 0) {
+    // Parse arguments with range support
+    const indices = expandRangeArgs(args);
+    if (!indices) {
         console.error("Usage: ralph prd toggle <number> [number2] [number3] ...");
+        console.error("       ralph prd toggle <start>-<end>");
         console.error("       ralph prd toggle --all");
         process.exit(1);
     }
@@ -194,8 +324,10 @@ export function prdToggle(args) {
             process.exit(1);
         }
     }
+    // Remove duplicates and sort
+    const uniqueIndices = [...new Set(indices)].sort((a, b) => a - b);
     // Toggle each entry
-    for (const index of indices) {
+    for (const index of uniqueIndices) {
         const entry = prd[index - 1];
         entry.passes = !entry.passes;
         const statusText = entry.passes ? "PASSING" : "NOT PASSING";
@@ -216,6 +348,29 @@ export function prdClean() {
     console.log(`Removed ${removed} passing ${removed === 1 ? "entry" : "entries"}.`);
     console.log(`${filtered.length} ${filtered.length === 1 ? "entry" : "entries"} remaining.`);
 }
+export async function prdReset() {
+    const prd = loadPrd();
+    if (prd.length === 0) {
+        console.log("No PRD entries to reset.");
+        return;
+    }
+    const alreadyPassing = prd.filter((e) => e.passes).length;
+    if (alreadyPassing === 0) {
+        console.log("All PRD entries are already incomplete (passes=false).");
+        return;
+    }
+    const confirmed = await promptConfirm(`Are you sure you want to reset ${alreadyPassing} ${alreadyPassing === 1 ? "entry" : "entries"} to incomplete?`, false);
+    if (!confirmed) {
+        console.log("Reset cancelled.");
+        return;
+    }
+    prd.forEach((entry) => {
+        entry.passes = false;
+    });
+    savePrd(prd);
+    console.log(`Reset ${alreadyPassing} ${alreadyPassing === 1 ? "entry" : "entries"} to incomplete.`);
+    console.log(`All ${prd.length} PRD ${prd.length === 1 ? "entry is" : "entries are"} now passes=false.`);
+}
 export function parseListArgs(args) {
     let category;
     let passesFilter;
@@ -260,29 +415,43 @@ export async function prd(args) {
             prdList(category, passesFilter);
             break;
         }
-        case "status":
-            prdStatus();
+        case "status": {
+            const headOnly = args.slice(1).includes("--head");
+            prdStatus(headOnly);
             break;
+        }
         case "toggle":
             prdToggle(args.slice(1));
             break;
         case "clean":
             prdClean();
             break;
+        case "reset":
+            await prdReset();
+            break;
+        case "convert":
+            await prdConvert(args.slice(1));
+            break;
         default:
-            console.error("Usage: ralph prd <add|list|status|toggle|clean>");
+            console.error("Usage: ralph prd <add|list|status|toggle|clean|reset|convert>");
             console.error("\nSubcommands:");
             console.error("  add                         Add a new PRD entry");
             console.error("  list [options]              List all PRD entries");
-            console.error("  status                      Show completion status");
+            console.error("  status [--head]             Show completion status");
             console.error("  toggle <n> ...              Toggle passes status for entry n (accepts multiple)");
+            console.error("  toggle <start>-<end>        Toggle a range of entries (e.g., 1-18)");
             console.error("  toggle --all                Toggle all PRD entries");
             console.error("  clean                       Remove all passing entries from the PRD");
+            console.error("  reset                       Reset all entries to incomplete (passes=false)");
+            console.error("  convert [options]           Convert prd.json to prd.yaml format");
             console.error("\nList options:");
             console.error("  --category, -c <cat>        Filter by category");
             console.error("  --passes                    Show only completed items");
             console.error("  --no-passes                 Show only incomplete items");
             console.error("  --stats                     Show statistics instead of entries");
+            console.error("\nConvert options:");
+            console.error("  --force, -f                 Overwrite existing files");
+            console.error("  --dry-run, -n               Preview without making changes");
             console.error(`\nValid categories: ${CATEGORIES.join(", ")}`);
             process.exit(1);
     }

package/dist/commands/prompt.js

@@ -13,7 +13,7 @@ USAGE:
 
 DESCRIPTION:
   Prints the complete prompt that gets sent to Claude Code, including
-  the @.ralph/prd.json and @.ralph/progress.txt file references.
+  the @.ralph/prd.yaml and @.ralph/progress.txt file references.
   This is useful for testing the prompt manually in Claude Code.
 
 TEMPLATE VARIABLES:

package/dist/commands/run.js

@@ -1,9 +1,9 @@
 import { spawn } from "child_process";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, appendFileSync, mkdirSync } from "fs";
-import { join } from "path";
+import { extname, join } from "path";
 import { checkFilesExist, loadConfig, loadPrompt, getPaths, getCliConfig, requireContainer, } from "../utils/config.js";
 import { resolvePromptVariables, getCliProviders } from "../templates/prompts.js";
-import { validatePrd, smartMerge, readPrdFile, writePrd, expandPrdFileReferences, } from "../utils/prd-validator.js";
+import { validatePrd, smartMerge, readPrdFile, writePrd, writePrdAuto, expandPrdFileReferences, } from "../utils/prd-validator.js";
 import { getStreamJsonParser } from "../utils/stream-json.js";
 import { sendNotificationWithDaemonEvents } from "../utils/notification.js";
 const CATEGORIES = ["ui", "feature", "bugfix", "setup", "development", "testing", "docs"];
@@ -14,24 +14,23 @@ const CATEGORIES = ["ui", "feature", "bugfix", "setup", "development", "testing"
  * Returns the path to the temp file, or null if all items pass.
  */
 function createFilteredPrd(prdPath, baseDir, category) {
-    const content = readFileSync(prdPath, "utf-8");
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch {
-        console.error("\x1b[31mError: prd.json contains invalid JSON.\x1b[0m");
+    // Use readPrdFile to handle both JSON and YAML formats
+    const parsed = readPrdFile(prdPath);
+    if (!parsed) {
+        const ext = extname(prdPath).toLowerCase();
+        const format = ext === ".yaml" || ext === ".yml" ? "YAML" : "JSON";
+        console.error(`\x1b[31mError: PRD file contains invalid ${format}.\x1b[0m`);
         console.error("The file may have been corrupted by an LLM.\n");
         console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
         process.exit(1);
     }
-    if (!Array.isArray(parsed)) {
-        console.error("\x1b[31mError: prd.json is corrupted - expected an array of items.\x1b[0m");
+    if (!Array.isArray(parsed.content)) {
+        console.error("\x1b[31mError: PRD is corrupted - expected an array of items.\x1b[0m");
         console.error("The file may have been modified incorrectly by an LLM.\n");
         console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
         process.exit(1);
     }
-    const items = parsed;
+    const items = parsed.content;
     let filteredItems = items.filter((item) => item.passes === false);
     // Apply category filter if specified
     if (category) {
@@ -48,9 +47,9 @@ function createFilteredPrd(prdPath, baseDir, category) {
     };
 }
 /**
- * Syncs passes flags from prd-tasks.json back to prd.json.
+ * Syncs passes flags from prd-tasks.json back to the main PRD file.
  * If the LLM marked any item as passes: true in prd-tasks.json,
- * find the matching item in prd.json and update it.
+ * find the matching item in the PRD and update it.
  * Returns the number of items synced and their names.
  */
 function syncPassesFromTasks(tasksPath, prdPath) {
@@ -66,22 +65,21 @@ function syncPassesFromTasks(tasksPath, prdPath) {
             return { count: 0, taskNames: [] };
         }
         const tasks = tasksParsed;
-        const prdContent = readFileSync(prdPath, "utf-8");
-        let prdParsed;
-        try {
-            prdParsed = JSON.parse(prdContent);
-        }
-        catch {
-            console.warn("\x1b[33mWarning: prd.json contains invalid JSON - skipping sync.\x1b[0m");
+        // Use readPrdFile to handle both JSON and YAML formats
+        const prdParsed = readPrdFile(prdPath);
+        if (!prdParsed) {
+            const ext = extname(prdPath).toLowerCase();
+            const format = ext === ".yaml" || ext === ".yml" ? "YAML" : "JSON";
+            console.warn(`\x1b[33mWarning: PRD contains invalid ${format} - skipping sync.\x1b[0m`);
             console.warn("Run \x1b[36mralph fix-prd\x1b[0m after this session to repair.\n");
             return { count: 0, taskNames: [] };
         }
-        if (!Array.isArray(prdParsed)) {
-            console.warn("\x1b[33mWarning: prd.json is corrupted - skipping sync.\x1b[0m");
+        if (!Array.isArray(prdParsed.content)) {
+            console.warn("\x1b[33mWarning: PRD is corrupted - skipping sync.\x1b[0m");
             console.warn("Run \x1b[36mralph fix-prd\x1b[0m after this session to repair.\n");
             return { count: 0, taskNames: [] };
         }
-        const prd = prdParsed;
+        const prd = prdParsed.content;
         let synced = 0;
         const syncedTaskNames = [];
         // Find tasks that were marked as passing
@@ -98,10 +96,11 @@ function syncPassesFromTasks(tasksPath, prdPath) {
                 }
             }
         }
-        // Write back if any items were synced
+        // Write back if any items were synced (using format-aware write)
         if (synced > 0) {
-            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`);
+            writePrdAuto(prdPath, prd);
+            const prdFileName = prdPath.split("/").pop() || "PRD";
+            console.log(`\x1b[32mSynced ${synced} completed item(s) from prd-tasks.json to ${prdFileName}\x1b[0m`);
         }
         return { count: synced, taskNames: syncedTaskNames };
     }
@@ -277,24 +276,23 @@ function formatElapsedTime(startTime, endTime) {
  * Optionally filters by category if specified.
  */
 function countPrdItems(prdPath, category) {
-    const content = readFileSync(prdPath, "utf-8");
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch {
-        console.error("\x1b[31mError: prd.json contains invalid JSON.\x1b[0m");
+    // Use readPrdFile to handle both JSON and YAML formats
+    const parsed = readPrdFile(prdPath);
+    if (!parsed) {
+        const ext = extname(prdPath).toLowerCase();
+        const format = ext === ".yaml" || ext === ".yml" ? "YAML" : "JSON";
+        console.error(`\x1b[31mError: PRD contains invalid ${format}.\x1b[0m`);
         console.error("The file may have been corrupted by an LLM.\n");
         console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
         process.exit(1);
     }
-    if (!Array.isArray(parsed)) {
-        console.error("\x1b[31mError: prd.json is corrupted - expected an array of items.\x1b[0m");
+    if (!Array.isArray(parsed.content)) {
+        console.error("\x1b[31mError: PRD is corrupted - expected an array of items.\x1b[0m");
         console.error("The file may have been modified incorrectly by an LLM.\n");
         console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
         process.exit(1);
     }
-    const items = parsed;
+    const items = parsed.content;
     let filteredItems = items;
     if (category) {
         filteredItems = items.filter((item) => item.category === category);
@@ -347,15 +345,16 @@ function validateAndRecoverPrd(prdPath, validPrd) {
  * Returns the validated PRD entries.
  */
 function loadValidPrd(prdPath) {
-    const content = readFileSync(prdPath, "utf-8");
-    try {
-        return JSON.parse(content);
-    }
-    catch {
-        console.error("\x1b[31mError: prd.json contains invalid JSON.\x1b[0m");
+    // Use readPrdFile to handle both JSON and YAML formats
+    const parsed = readPrdFile(prdPath);
+    if (!parsed || !Array.isArray(parsed.content)) {
+        const ext = extname(prdPath).toLowerCase();
+        const format = ext === ".yaml" || ext === ".yml" ? "YAML" : "JSON";
+        console.error(`\x1b[31mError: PRD contains invalid ${format}.\x1b[0m`);
         console.error("Run \x1b[36mralph fix-prd\x1b[0m to diagnose and repair the file.");
         process.exit(1);
     }
+    return parsed.content;
 }
 export async function run(args) {
     // Parse flags

package/dist/index.js

@@ -6,7 +6,7 @@ import { help } from "./commands/help.js";
 import { init } from "./commands/init.js";
 import { once } from "./commands/once.js";
 import { run } from "./commands/run.js";
-import { prd, prdAdd, prdList, prdStatus, prdToggle, prdClean, parseListArgs, } from "./commands/prd.js";
+import { prd, prdAdd, prdList, prdStatus, prdToggle, prdClean, prdReset, parseListArgs, } from "./commands/prd.js";
 import { docker } from "./commands/docker.js";
 import { prompt } from "./commands/prompt.js";
 import { fixPrd } from "./commands/fix-prd.js";
@@ -51,9 +51,13 @@ const commands = {
         const { category, passesFilter } = parseListArgs(args);
         prdList(category, passesFilter);
     },
-    status: () => prdStatus(),
+    status: (args) => {
+        const headOnly = args.includes("--head");
+        prdStatus(headOnly);
+    },
     toggle: (args) => prdToggle(args),
     clean: () => prdClean(),
+    reset: () => prdReset(),
 };
 async function main() {
     const args = process.argv.slice(2);

package/dist/templates/prompts.d.ts

@@ -75,5 +75,6 @@ export declare function resolvePromptVariables(template: string, config: {
 }): string;
 export declare function generatePrompt(config: LanguageConfig, technologies?: string[]): string;
 export declare const DEFAULT_PRD = "[\n  {\n    \"category\": \"setup\",\n    \"description\": \"Example: Project builds successfully\",\n    \"steps\": [\n      \"Run the build command\",\n      \"Verify no errors occur\"\n    ],\n    \"passes\": false\n  }\n]";
+export declare const DEFAULT_PRD_YAML = "- category: setup\n  description: \"Example: Project builds successfully\"\n  steps:\n    - Run the build command\n    - Verify no errors occur\n  passes: false\n";
 export declare const DEFAULT_PROGRESS = "# Progress Log\n";
 export {};

package/dist/templates/prompts.js

@@ -105,7 +105,7 @@ INSTRUCTIONS:
 3. Verify your changes work by running:
    - Type/build check: $checkCommand
    - Tests: $testCommand
-4. Update .ralph/prd.json to set "passes": true for the completed feature
+4. Update .ralph/prd.yaml to set "passes": true for the completed feature
 5. Append a brief note about what you did to .ralph/progress.txt
 6. Create a git commit with a descriptive message for this feature
 7. Only work on ONE feature per execution
@@ -152,4 +152,11 @@ export const DEFAULT_PRD = `[
     "passes": false
   }
 ]`;
+export const DEFAULT_PRD_YAML = `- category: setup
+  description: "Example: Project builds successfully"
+  steps:
+    - Run the build command
+    - Verify no errors occur
+  passes: false
+`;
 export const DEFAULT_PROGRESS = `# Progress Log\n`;

package/dist/utils/config.d.ts

@@ -193,6 +193,24 @@ export interface RalphConfig {
 }
 export declare const DEFAULT_CLI_CONFIG: CliConfig;
 export declare function getCliConfig(config: RalphConfig): CliConfig;
+/**
+ * Gets the PRD file path(s) that exist.
+ * Returns an object with:
+ * - primary: The main PRD file path to use (yaml preferred over json)
+ * - secondary: The secondary PRD file path if both exist (for merging)
+ * - jsonOnly: True if only prd.json exists (shows migration notice)
+ * - yamlOnly: True if only prd.yaml exists (happy path)
+ * - both: True if both files exist (merge mode)
+ * - none: True if no PRD file exists
+ */
+export declare function getPrdFiles(): {
+    primary: string | null;
+    secondary: string | null;
+    jsonOnly: boolean;
+    yamlOnly: boolean;
+    both: boolean;
+    none: boolean;
+};
 export declare function getRalphDir(): string;
 export declare function loadConfig(): RalphConfig;
 export declare function loadPrompt(): string;
@@ -202,6 +220,7 @@ export declare function getPaths(): {
     config: string;
     prompt: string;
     prd: string;
+    prdSecondary: string | null;
     progress: string;
 };
 /**