ralph-cli-sandboxed 0.6.2 → 0.6.3

package/dist/commands/help.js

@@ -92,7 +92,7 @@ BRANCH SUBCOMMANDS:
   branch list           List all branches and their status
   branch merge <name>   Merge a branch worktree into the base branch
   branch delete <name>  Delete a branch and remove its worktree
-  branch pr <name>      Create a PRD item to open a PR for a branch
+  branch pr <name>      Create a pull request for a branch using gh CLI
 
 PROGRESS SUBCOMMANDS:
   progress summarize    Add a PRD entry to summarize and compact progress.txt
@@ -149,7 +149,7 @@ EXAMPLES:
   ralph branch list              # List all branches and their PRD status
   ralph branch merge feat/login  # Merge feat/login branch into base branch
   ralph branch delete feat/old   # Delete branch and its worktree
-  ralph branch pr feat/login     # Add PRD item to create PR for feat/login
+  ralph branch pr feat/login     # Create a GitHub PR for feat/login
   ralph progress summarize   # Add PRD entry to summarize progress.txt
 
 CONFIGURATION:

package/dist/commands/prd.js

@@ -5,6 +5,7 @@ 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";
+import { robustYamlParse } from "../utils/prd-validator.js";
 const PRD_FILE_JSON = "prd.json";
 const PRD_FILE_YAML = "prd.yaml";
 const CATEGORIES = ["ui", "feature", "bugfix", "setup", "development", "testing", "docs"];
@@ -29,7 +30,7 @@ function parsePrdFile(path) {
     try {
         let result;
         if (ext === ".yaml" || ext === ".yml") {
-            result = YAML.parse(content);
+            result = robustYamlParse(content);
         }
         else {
             result = JSON.parse(content);
@@ -227,6 +228,24 @@ export function prdStatus(headOnly = false) {
     Object.entries(byCategory).forEach(([cat, stats]) => {
         console.log(`    ${cat}: ${stats.pass}/${stats.total}`);
     });
+    // By branch (only if any entries have a branch)
+    const hasBranches = prd.some((e) => e.branch);
+    if (hasBranches) {
+        const byBranch = {};
+        prd.forEach((entry) => {
+            const key = entry.branch || "(no branch)";
+            if (!byBranch[key]) {
+                byBranch[key] = { pass: 0, total: 0 };
+            }
+            byBranch[key].total++;
+            if (entry.passes)
+                byBranch[key].pass++;
+        });
+        console.log("\n  By branch:");
+        Object.entries(byBranch).forEach(([br, stats]) => {
+            console.log(`    ${br}: ${stats.pass}/${stats.total}`);
+        });
+    }
     if (passing === total) {
         console.log("\n  \x1b[32m\u2713 All requirements complete!\x1b[0m");
     }
@@ -234,7 +253,8 @@ export function prdStatus(headOnly = false) {
         const remaining = prd.filter((e) => !e.passes);
         console.log(`\n  Remaining (${remaining.length}):`);
         remaining.forEach((entry) => {
-            console.log(`    - [${entry.category}] ${entry.description}`);
+            const branchTag = entry.branch ? ` \x1b[36m(${entry.branch})\x1b[0m` : "";
+            console.log(`    - [${entry.category}] ${entry.description}${branchTag}`);
         });
     }
 }

package/dist/commands/progress.js

@@ -3,6 +3,7 @@ import { extname, join } from "path";
 import { getRalphDir, getPrdFiles } from "../utils/config.js";
 import { DEFAULT_PRD_YAML } from "../templates/prompts.js";
 import YAML from "yaml";
+import { robustYamlParse } from "../utils/prd-validator.js";
 const PRD_FILE_YAML = "prd.yaml";
 const PRD_FILE_JSON = "prd.json";
 function getPrdPath() {
@@ -18,7 +19,7 @@ function parsePrdFile(path) {
     try {
         let result;
         if (ext === ".yaml" || ext === ".yml") {
-            result = YAML.parse(content);
+            result = robustYamlParse(content);
         }
         else {
             result = JSON.parse(content);

package/dist/commands/run.js

@@ -888,15 +888,32 @@ export async function run(args) {
                     // Default to "main"
                 }
             }
+            // Merge items tagged with the base branch into the no-branch group,
+            // so they run in /workspace instead of creating a worktree.
+            const baseBranchItems = branchGroups.get(baseBranch);
+            if (baseBranchItems && baseBranchItems.length > 0) {
+                const noBranch = branchGroups.get("") || [];
+                branchGroups.set("", [...noBranch, ...baseBranchItems]);
+                branchGroups.delete(baseBranch);
+            }
             // Find the first incomplete item to determine which group to process.
             // If resuming from a previous interruption, prioritize the resumed branch.
             let targetBranch;
             if (resumedBranchState) {
                 targetBranch = resumedBranchState.currentBranch;
+                // If resumed branch is the base branch, treat as no-branch
+                if (targetBranch === baseBranch) {
+                    targetBranch = "";
+                    clearBranchState();
+                }
             }
             else {
                 const firstIncomplete = itemsForIteration.find((item) => !item.passes);
                 targetBranch = firstIncomplete?.branch || "";
+                // If the target matches the base branch, treat as no-branch
+                if (targetBranch === baseBranch) {
+                    targetBranch = "";
+                }
             }
             if (targetBranch !== "" && worktreesAvailable && hasCommits) {
                 // Process this one branch group in its worktree

package/dist/utils/prd-validator.d.ts

@@ -57,6 +57,11 @@ export declare function findLatestBackup(prdPath: string): string | null;
  * @param backupPath - Absolute path to the backup file containing the corrupted PRD
  */
 export declare function createTemplatePrd(backupPath?: string): PrdEntry[];
+/**
+ * Robustly parses YAML content, applying automatic fixes for common
+ * LLM-generated YAML issues (multiline strings, embedded quotes).
+ */
+export declare function robustYamlParse(content: string): unknown;
 /**
  * Reads and parses a YAML PRD file.
  * Attempts to fix common LLM-caused YAML issues before parsing.

package/dist/utils/prd-validator.js

@@ -425,6 +425,64 @@ export function createTemplatePrd(backupPath) {
         },
     ];
 }
+/**
+ * Checks if a YAML plain scalar value contains embedded double-quoted segments
+ * with YAML special characters that would cause parsing issues.
+ *
+ * Example: Add "server: { port: 9999 }" to vite.config.ts
+ * The parser interprets "server: { port: 9999 }" as a double-quoted scalar,
+ * then finds unexpected text after the closing quote.
+ */
+function hasProblematicEmbeddedQuotes(value) {
+    // Look for "...special chars..." followed by more text
+    const regex = /"[^"]*[:{}\[\]][^"]*"/g;
+    let match;
+    while ((match = regex.exec(value)) !== null) {
+        const afterQuote = value.substring(match.index + match[0].length);
+        if (afterQuote.trim().length > 0) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Fixes YAML values that contain embedded double-quoted strings with special characters.
+ *
+ * Example problematic line:
+ *   - Add "server: { port: 9999 }" to vite.config.ts
+ *
+ * The YAML parser interprets "server: { port: 9999 }" as a double-quoted scalar,
+ * then chokes on the trailing text. Fix: wrap the entire value in single quotes.
+ */
+function fixYamlEmbeddedQuotes(yaml) {
+    const lines = yaml.split("\n");
+    const result = [];
+    for (const line of lines) {
+        // Try list item: `  - value`
+        let match = line.match(/^(\s*-\s+)(.+)$/);
+        if (!match) {
+            // Try key-value: `  key: value`
+            match = line.match(/^(\s*[a-zA-Z_][a-zA-Z0-9_]*:\s+)(.+)$/);
+        }
+        if (match) {
+            const prefix = match[1];
+            const value = match[2];
+            // Skip if already quoted
+            if (value.startsWith('"') || value.startsWith("'") || value.startsWith("|") || value.startsWith(">")) {
+                result.push(line);
+                continue;
+            }
+            if (hasProblematicEmbeddedQuotes(value)) {
+                // Wrap in single quotes, escaping existing single quotes by doubling
+                const escaped = value.replace(/'/g, "''");
+                result.push(`${prefix}'${escaped}'`);
+                continue;
+            }
+        }
+        result.push(line);
+    }
+    return result.join("\n");
+}
 /**
  * Fixes common YAML issues caused by LLMs writing multi-line strings incorrectly.
  * The main issue is list items that span multiple lines without proper quoting:
@@ -492,6 +550,19 @@ function fixYamlMultilineStrings(yaml) {
     }
     return result.join("\n");
 }
+/**
+ * Robustly parses YAML content, applying automatic fixes for common
+ * LLM-generated YAML issues (multiline strings, embedded quotes).
+ */
+export function robustYamlParse(content) {
+    try {
+        return YAML.parse(content);
+    }
+    catch {
+        const fixed = fixYamlEmbeddedQuotes(fixYamlMultilineStrings(content));
+        return YAML.parse(fixed);
+    }
+}
 /**
  * Common wrapper keys that LLMs use to wrap PRD arrays.
  * If parsed content is an object with one of these keys containing an array,
@@ -524,14 +595,13 @@ function unwrapPrdContent(content) {
 export function readYamlPrdFile(prdPath) {
     try {
         const raw = readFileSync(prdPath, "utf-8");
-        // Try parsing as-is first
+        // Try parsing as-is first, then with fixes for common LLM issues
         let content;
         try {
             content = YAML.parse(raw);
         }
         catch {
-            // Try fixing common issues and parse again
-            const fixed = fixYamlMultilineStrings(raw);
+            const fixed = fixYamlEmbeddedQuotes(fixYamlMultilineStrings(raw));
             content = YAML.parse(fixed);
         }
         // Unwrap if wrapped in common object structure
@@ -556,13 +626,12 @@ export function readPrdFile(prdPath) {
         // Parse based on file extension
         let content;
         if (ext === ".yaml" || ext === ".yml") {
-            // Try parsing as-is first
+            // Try parsing as-is first, then with fixes for common LLM issues
             try {
                 content = YAML.parse(raw);
             }
             catch {
-                // Try fixing common issues and parse again
-                const fixed = fixYamlMultilineStrings(raw);
+                const fixed = fixYamlEmbeddedQuotes(fixYamlMultilineStrings(raw));
                 content = YAML.parse(fixed);
                 // Unwrap if wrapped in common object structure
                 content = unwrapPrdContent(content);

package/dist/utils/vcs-git.d.ts

@@ -0,0 +1,36 @@
+/**
+ * GitProvider — implements VcsProvider using git commands.
+ */
+import type { VcsProvider, VcsExecOptions, MergeResult, DiffPattern } from "./vcs.js";
+export declare class GitProvider implements VcsProvider {
+    readonly type: "git";
+    hasCommits(opts?: VcsExecOptions): boolean;
+    getCurrentBranch(opts?: VcsExecOptions): string;
+    branchExists(name: string, opts?: VcsExecOptions): boolean;
+    status(opts?: VcsExecOptions): string;
+    createBranch(name: string, opts?: VcsExecOptions): void;
+    deleteBranch(name: string, opts?: VcsExecOptions): void;
+    diff(opts?: VcsExecOptions): string;
+    diffStaged(opts?: VcsExecOptions): string;
+    diffAll(opts?: VcsExecOptions): string;
+    showCommit(revisionOffset: number, opts?: VcsExecOptions): string;
+    commit(message: string, opts?: VcsExecOptions): void;
+    merge(branchName: string, opts?: VcsExecOptions): MergeResult;
+    mergeAbort(opts?: VcsExecOptions): void;
+    getConflictingFiles(opts?: VcsExecOptions): string[];
+    getRemote(opts?: VcsExecOptions): string;
+    hasUpstream(branchName: string, opts?: VcsExecOptions): boolean;
+    push(remote: string, branchName: string, opts?: VcsExecOptions): void;
+    logBetween(base: string, head: string, opts?: VcsExecOptions): string;
+    createWorkspace(path: string, branch: string, createBranch: boolean, opts?: VcsExecOptions): void;
+    removeWorkspace(path: string, force?: boolean, opts?: VcsExecOptions): void;
+    getDockerConfigCommands(dockerConfig?: {
+        git?: {
+            name?: string;
+            email?: string;
+        };
+    }): string[];
+    getDockerInstallSnippet(): string;
+    getCommitInstruction(): string;
+    getDiffPatterns(): DiffPattern[];
+}

package/dist/utils/vcs-git.js

@@ -0,0 +1,193 @@
+/**
+ * GitProvider — implements VcsProvider using git commands.
+ */
+import { execSync } from "child_process";
+export class GitProvider {
+    type = "git";
+    hasCommits(opts) {
+        try {
+            execSync("git rev-parse HEAD", { stdio: "pipe", ...opts });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getCurrentBranch(opts) {
+        try {
+            return execSync("git rev-parse --abbrev-ref HEAD", {
+                encoding: "utf-8",
+                ...opts,
+            }).trim();
+        }
+        catch {
+            return "main";
+        }
+    }
+    branchExists(name, opts) {
+        try {
+            execSync(`git rev-parse --verify "${name}"`, { stdio: "pipe", ...opts });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    status(opts) {
+        return execSync("git status --porcelain", {
+            encoding: "utf-8",
+            ...opts,
+        });
+    }
+    createBranch(name, opts) {
+        execSync(`git checkout -b "${name}"`, { stdio: "pipe", ...opts });
+    }
+    deleteBranch(name, opts) {
+        execSync(`git branch -D "${name}"`, { stdio: "pipe", ...opts });
+    }
+    diff(opts) {
+        return execSync("git diff", {
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024,
+            timeout: 10000,
+            ...opts,
+        }).trim();
+    }
+    diffStaged(opts) {
+        return execSync("git diff --cached", {
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024,
+            timeout: 10000,
+            ...opts,
+        }).trim();
+    }
+    diffAll(opts) {
+        return execSync("git diff HEAD", {
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024,
+            timeout: 10000,
+            ...opts,
+        }).trim();
+    }
+    showCommit(revisionOffset, opts) {
+        const ref = revisionOffset === 0 ? "HEAD" : `HEAD~${revisionOffset}`;
+        return execSync(`git show ${ref} --stat --patch`, {
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024,
+            timeout: 10000,
+            ...opts,
+        }).trim();
+    }
+    commit(message, opts) {
+        execSync(`git add -A && git commit -m "${message.replace(/"/g, '\\"')}"`, {
+            stdio: "pipe",
+            ...opts,
+        });
+    }
+    merge(branchName, opts) {
+        try {
+            execSync(`git merge "${branchName}" --no-edit`, { stdio: "pipe", ...opts });
+            return { success: true };
+        }
+        catch {
+            const conflictingFiles = this.getConflictingFiles(opts);
+            return { success: false, conflictingFiles };
+        }
+    }
+    mergeAbort(opts) {
+        try {
+            execSync("git merge --abort", { stdio: "pipe", ...opts });
+        }
+        catch {
+            // Ignore if nothing to abort
+        }
+    }
+    getConflictingFiles(opts) {
+        try {
+            const status = execSync("git status --porcelain", { encoding: "utf-8", ...opts });
+            return status
+                .split("\n")
+                .filter((line) => line.startsWith("UU") ||
+                line.startsWith("AA") ||
+                line.startsWith("DD") ||
+                line.startsWith("AU") ||
+                line.startsWith("UA") ||
+                line.startsWith("DU") ||
+                line.startsWith("UD"))
+                .map((line) => line.substring(3).trim());
+        }
+        catch {
+            return [];
+        }
+    }
+    getRemote(opts) {
+        return execSync("git remote", { encoding: "utf-8", ...opts }).trim().split("\n")[0];
+    }
+    hasUpstream(branchName, opts) {
+        try {
+            execSync(`git rev-parse --abbrev-ref "${branchName}@{upstream}"`, {
+                stdio: "pipe",
+                ...opts,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    push(remote, branchName, opts) {
+        execSync(`git push -u "${remote}" "${branchName}"`, { stdio: "pipe", ...opts });
+    }
+    logBetween(base, head, opts) {
+        return execSync(`git log "${base}..${head}" --oneline --no-decorate`, {
+            encoding: "utf-8",
+            ...opts,
+        }).trim();
+    }
+    createWorkspace(path, branch, createBranch, opts) {
+        if (createBranch) {
+            execSync(`git worktree add -b "${branch}" "${path}"`, { stdio: "pipe", ...opts });
+        }
+        else {
+            execSync(`git worktree add "${path}" "${branch}"`, { stdio: "pipe", ...opts });
+        }
+    }
+    removeWorkspace(path, force, opts) {
+        const forceFlag = force ? " --force" : "";
+        execSync(`git worktree remove "${path}"${forceFlag}`, { stdio: "pipe", ...opts });
+    }
+    getDockerConfigCommands(dockerConfig) {
+        const commands = [`git config --global init.defaultBranch main`];
+        if (dockerConfig?.git?.name) {
+            commands.push(`git config --global user.name "${dockerConfig.git.name}"`);
+        }
+        if (dockerConfig?.git?.email) {
+            commands.push(`git config --global user.email "${dockerConfig.git.email}"`);
+        }
+        return commands;
+    }
+    getDockerInstallSnippet() {
+        // Git is already installed in the base Docker image
+        return "";
+    }
+    getCommitInstruction() {
+        return "Create a git commit with a descriptive message for this feature";
+    }
+    getDiffPatterns() {
+        return [
+            { pattern: /^(diff|changes)$/i, command: "git diff", description: "unstaged changes" },
+            { pattern: /^staged$/i, command: "git diff --cached", description: "staged changes" },
+            {
+                pattern: /^(last|last\s*commit)$/i,
+                command: "git show HEAD --stat --patch",
+                description: "last commit",
+            },
+            {
+                pattern: /^HEAD~(\d+)$/i,
+                command: "git show HEAD~$1 --stat --patch",
+                description: "commit",
+            },
+            { pattern: /^all$/i, command: "git diff HEAD", description: "all uncommitted changes" },
+        ];
+    }
+}

package/dist/utils/vcs-jj.d.ts

@@ -0,0 +1,36 @@
+/**
+ * JjProvider — implements VcsProvider using Jujutsu (jj) commands.
+ */
+import type { VcsProvider, VcsExecOptions, MergeResult, DiffPattern } from "./vcs.js";
+export declare class JjProvider implements VcsProvider {
+    readonly type: "jj";
+    hasCommits(opts?: VcsExecOptions): boolean;
+    getCurrentBranch(opts?: VcsExecOptions): string;
+    branchExists(name: string, opts?: VcsExecOptions): boolean;
+    status(opts?: VcsExecOptions): string;
+    createBranch(name: string, opts?: VcsExecOptions): void;
+    deleteBranch(name: string, opts?: VcsExecOptions): void;
+    diff(opts?: VcsExecOptions): string;
+    diffStaged(_opts?: VcsExecOptions): string;
+    diffAll(opts?: VcsExecOptions): string;
+    showCommit(revisionOffset: number, opts?: VcsExecOptions): string;
+    commit(message: string, opts?: VcsExecOptions): void;
+    merge(branchName: string, opts?: VcsExecOptions): MergeResult;
+    mergeAbort(opts?: VcsExecOptions): void;
+    getConflictingFiles(opts?: VcsExecOptions): string[];
+    getRemote(opts?: VcsExecOptions): string;
+    hasUpstream(branchName: string, opts?: VcsExecOptions): boolean;
+    push(remote: string, branchName: string, opts?: VcsExecOptions): void;
+    logBetween(base: string, head: string, opts?: VcsExecOptions): string;
+    createWorkspace(path: string, _branch: string, _createBranch: boolean, opts?: VcsExecOptions): void;
+    removeWorkspace(path: string, _force?: boolean, opts?: VcsExecOptions): void;
+    getDockerConfigCommands(dockerConfig?: {
+        git?: {
+            name?: string;
+            email?: string;
+        };
+    }): string[];
+    getDockerInstallSnippet(): string;
+    getCommitInstruction(): string;
+    getDiffPatterns(): DiffPattern[];
+}