claude-ralph 1.0.0

package/dist/cli.js

@@ -0,0 +1,775 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import fs7 from 'fs-extra';
+import path7 from 'path';
+import chalk4 from 'chalk';
+import { cosmiconfig } from 'cosmiconfig';
+import { z } from 'zod';
+import { execa, execaSync } from 'execa';
+
+var logger = {
+  info(message) {
+    console.log(chalk4.blue("[INFO]"), message);
+  },
+  success(message) {
+    console.log(chalk4.green("[SUCCESS]"), message);
+  },
+  warning(message) {
+    console.log(chalk4.yellow("[WARNING]"), message);
+  },
+  error(message) {
+    console.log(chalk4.red("[ERROR]"), message);
+  },
+  log(message) {
+    console.log(message);
+  },
+  header(title) {
+    console.log("");
+    console.log(chalk4.bold("========================================"));
+    console.log(chalk4.bold(`  ${title}`));
+    console.log(chalk4.bold("========================================"));
+    console.log("");
+  },
+  divider() {
+    console.log(chalk4.gray("----------------------------------------"));
+  },
+  list(items, indent = 2) {
+    const prefix = " ".repeat(indent) + "- ";
+    for (const item of items) {
+      console.log(prefix + item);
+    }
+  },
+  keyValue(key, value) {
+    console.log(`  ${chalk4.cyan(key)}: ${value}`);
+  }
+};
+var RepositoryConfigSchema = z.object({
+  path: z.string(),
+  defaultBranch: z.string().default("main"),
+  checks: z.array(z.string()).default([])
+});
+var AgentConfigSchema = z.object({
+  maxIterations: z.number().default(50),
+  timeout: z.number().default(600)
+});
+var RalphConfigSchema = z.object({
+  $schema: z.string().optional(),
+  version: z.string().optional(),
+  project: z.string(),
+  description: z.string().optional(),
+  repositories: z.record(z.string(), RepositoryConfigSchema),
+  agent: AgentConfigSchema.optional().default({})
+});
+var PrdRepositorySchema = z.object({
+  branchName: z.string(),
+  activeBranch: z.string().optional()
+});
+var UserStorySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  repo: z.string(),
+  description: z.string(),
+  acceptanceCriteria: z.array(z.string()),
+  priority: z.number(),
+  passes: z.boolean().default(false),
+  fork: z.boolean().default(false),
+  notes: z.string().default("")
+});
+var PrdSchema = z.object({
+  project: z.string(),
+  description: z.string().optional(),
+  repositories: z.record(z.string(), PrdRepositorySchema),
+  userStories: z.array(UserStorySchema)
+});
+
+// src/core/config.ts
+var MODULE_NAME = "ralph";
+var explorer = cosmiconfig(MODULE_NAME, {
+  searchPlaces: [
+    "ralph.config.json",
+    ".ralphrc",
+    ".ralphrc.json",
+    ".ralphrc.yaml",
+    ".ralphrc.yml",
+    "package.json"
+  ]
+});
+var ConfigNotFoundError = class extends Error {
+  constructor(searchPath) {
+    super(
+      `No Ralph configuration found. Run 'ralph init' to create one, or create ralph.config.json manually.
+Searched from: ${searchPath}`
+    );
+    this.name = "ConfigNotFoundError";
+  }
+};
+var ConfigValidationError = class extends Error {
+  constructor(message) {
+    super(`Invalid configuration: ${message}`);
+    this.name = "ConfigValidationError";
+  }
+};
+async function loadConfig(cwd = process.cwd()) {
+  const result = await explorer.search(cwd);
+  if (!result || !result.config) {
+    throw new ConfigNotFoundError(cwd);
+  }
+  const parsed = RalphConfigSchema.safeParse(result.config);
+  if (!parsed.success) {
+    throw new ConfigValidationError(parsed.error.message);
+  }
+  return parsed.data;
+}
+async function configExists(cwd = process.cwd()) {
+  const result = await explorer.search(cwd);
+  return result !== null && result.config !== void 0;
+}
+function getDefaultConfig(projectName) {
+  return {
+    version: "1.0",
+    project: projectName,
+    description: "Project description",
+    repositories: {
+      main: {
+        path: ".",
+        defaultBranch: "main",
+        checks: ["npm run build", "npm run lint", "npm test"]
+      }
+    },
+    agent: {
+      maxIterations: 50,
+      timeout: 600
+    }
+  };
+}
+
+// src/commands/init.ts
+async function initCommand(options = {}) {
+  const cwd = process.cwd();
+  const configPath = path7.join(cwd, "ralph.config.json");
+  if (await configExists(cwd)) {
+    if (!options.force) {
+      logger.warning("Configuration already exists. Use --force to overwrite.");
+      return;
+    }
+    logger.info("Overwriting existing configuration...");
+  }
+  let projectName = path7.basename(cwd);
+  const packageJsonPath = path7.join(cwd, "package.json");
+  if (await fs7.pathExists(packageJsonPath)) {
+    try {
+      const pkg = await fs7.readJSON(packageJsonPath);
+      if (pkg.name) {
+        projectName = pkg.name;
+      }
+    } catch {
+    }
+  }
+  const config = getDefaultConfig(projectName);
+  await fs7.writeJSON(configPath, config, { spaces: 2 });
+  logger.success(`Created ralph.config.json`);
+  logger.log("");
+  logger.log("Next steps:");
+  logger.log("  1. Edit ralph.config.json to configure your repositories");
+  logger.log("  2. Run: ralph plan <feature>");
+  logger.log("  3. Run: ralph prd");
+  logger.log("  4. Run: ralph run");
+  const gitignorePath = path7.join(cwd, ".gitignore");
+  if (await fs7.pathExists(gitignorePath)) {
+    const gitignore = await fs7.readFile(gitignorePath, "utf-8");
+    const entries = ["plan.md", "prd.json", "progress.txt", "archive/", ".last-project"];
+    const toAdd = entries.filter((e) => !gitignore.includes(e));
+    if (toAdd.length > 0) {
+      const addition = `
+# Ralph
+${toAdd.join("\n")}
+`;
+      await fs7.appendFile(gitignorePath, addition);
+      logger.info(`Added ${toAdd.length} entries to .gitignore`);
+    }
+  }
+}
+async function run(command, args = [], options = {}) {
+  const result = await execa(command, args, {
+    reject: false,
+    ...options
+  });
+  return {
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? ""),
+    exitCode: result.exitCode ?? 1
+  };
+}
+function isCommandAvailable(command) {
+  try {
+    const result = execaSync("which", [command], { reject: false });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/claude.ts
+var ClaudeNotFoundError = class extends Error {
+  constructor() {
+    super(
+      "Claude Code CLI not found. Install it from: https://claude.ai/code"
+    );
+    this.name = "ClaudeNotFoundError";
+  }
+};
+function isClaudeInstalled() {
+  return isCommandAvailable("claude");
+}
+function checkClaudeInstalled() {
+  if (!isClaudeInstalled()) {
+    throw new ClaudeNotFoundError();
+  }
+}
+async function invokeClaudeStreaming(prompt, options = {}) {
+  checkClaudeInstalled();
+  const args = [];
+  if (options.print) {
+    args.push("--print");
+  }
+  if (options.skipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  }
+  const finalPrompt = options.ultrathink ? `ultrathink ${prompt}` : prompt;
+  if (options.print) {
+    args.push(finalPrompt);
+  }
+  const subprocess = execa("claude", args, {
+    cwd: options.cwd,
+    timeout: options.timeout ? options.timeout * 1e3 : void 0,
+    reject: false,
+    input: options.print ? void 0 : finalPrompt
+  });
+  subprocess.stderr?.pipe(process.stderr);
+  const result = await subprocess;
+  return result.stdout;
+}
+
+// src/templates/embedded/prompt.ts
+var PROMPT_TEMPLATE = '# Ralph Agent Instructions\n\nYou are an autonomous coding agent executing user stories from a PRD.\n\n## Your Task\n\n1. Read the PRD at `prd.json`\n2. Read the progress log at `progress.txt` (check Codebase Patterns section first)\n3. Read `ralph.config.json` to understand the project structure\n4. Pick the **highest priority** user story where `passes: false`\n5. Note which `repo` the story targets\n6. Ensure you\'re on the correct branch in that repo\n7. Implement that single user story\n8. Run quality checks for the target repo\n9. If checks pass, commit changes with message: `feat: [Story ID] - [Story Title]`\n10. Update `prd.json` to set `passes: true` for the completed story\n11. Append your progress to `progress.txt`\n\n## Configuration\n\nRead `ralph.config.json` to understand:\n- Available repositories and their paths\n- Quality checks to run for each repo\n- Project structure\n\nExample configuration:\n```json\n{\n  "repositories": {\n    "backend": {\n      "path": "./backend",\n      "checks": ["pytest", "mypy ."]\n    },\n    "frontend": {\n      "path": "./frontend",\n      "checks": ["npm run build", "npm run lint"]\n    }\n  }\n}\n```\n\n## Branch Management\n\nEach story specifies a `repo` field. Before implementing:\n\n1. **Check the story\'s `repo` field** (e.g., `"repo": "backend"`)\n2. **Get the repo path** from `ralph.config.json`\n3. **Navigate to that repo** and check/create the branch:\n   ```bash\n   cd <repo-path>\n   git checkout -b feature/my-feature  # or checkout existing branch\n   ```\n4. **After implementing, commit in that repo:**\n   ```bash\n   cd <repo-path>\n   git add .\n   git commit -m "feat: US-001 - Add status field"\n   ```\n\nThe PRD contains a `repositories` section with branch names for each repo:\n```json\n{\n  "repositories": {\n    "backend": { "branchName": "feature/task-status" },\n    "frontend": { "branchName": "feature/task-status" }\n  }\n}\n```\n\n## Branch Forking\n\nSome stories may request a "fork" - creating a new branch from the current one.\n\n### When to Fork\n\nCheck the story\'s `fork` field:\n- `"fork": true` - Create a new branch before implementing\n- `"fork": false` or not specified - Use the existing branch\n\n### Fork Algorithm\n\nIf `fork: true` for the current story:\n\n1. **Check if already forked**:\n   - If `repositories[repo].activeBranch` exists and differs from `branchName`, the fork already happened\n   - Just checkout `activeBranch` and continue\n\n2. **Detect next branch number:**\n   ```bash\n   cd <repo-path>\n   BASE_BRANCH=$(jq -r \'.repositories["<repo>"].branchName\' prd.json)\n   EXISTING=$(git branch --list "${BASE_BRANCH}-*" | tr -d \' *\')\n   # Find max number and increment\n   NEW_BRANCH="${BASE_BRANCH}-${NEXT_NUM}"\n   ```\n\n3. **Create and checkout new branch:**\n   ```bash\n   git checkout -b "$NEW_BRANCH"\n   ```\n\n4. **Update PRD** to reflect the new active branch\n\n## Quality Requirements\n\nBefore committing, run the quality checks from `ralph.config.json`:\n\n```bash\ncd <repo-path>\n# Run each check from config\n<check-command-1>\n<check-command-2>\n```\n\n**General Rules:**\n- ALL commits must pass quality checks\n- Do NOT commit broken code\n- Keep changes focused and minimal\n- Follow existing code patterns\n\n## Progress Report Format\n\nAPPEND to `progress.txt` (never replace, always append):\n```\n## [Date/Time] - [Story ID] ([repo])\n- What was implemented\n- Files changed\n- Commit: [commit hash]\n- **Learnings for future iterations:**\n  - Patterns discovered\n  - Gotchas encountered\n---\n```\n\n## Consolidate Patterns\n\nIf you discover a **reusable pattern**, add it to the `## Codebase Patterns` section at the TOP of `progress.txt`:\n\n```\n## Codebase Patterns\n\n### [repo-name]\n- Example: Use Pydantic models for request/response\n- Example: Routes are in `routers/` directory\n```\n\n## Update CLAUDE.md Files\n\nBefore committing, check if learnings should be added to the target repo\'s `CLAUDE.md` file.\n\n## Browser Testing (For Frontend Stories)\n\nFor any story that changes UI:\n\n1. Start the dev server\n2. Navigate to the relevant page\n3. Verify the UI changes work as expected\n4. A frontend story is NOT complete until browser verification passes\n\n## Stop Condition\n\nAfter completing a user story, check if ALL stories have `passes: true`.\n\nIf ALL stories are complete and passing, reply with:\n<promise>COMPLETE</promise>\n\nIf there are still stories with `passes: false`, end your response normally (another iteration will pick up the next story).\n\n## Important\n\n- Work on ONE story per iteration\n- Each story targets ONE repository\n- Read the story\'s `repo` field to know which repo to work in\n- Use the correct branch for each repo (from PRD `repositories` section)\n- Read the Codebase Patterns section in `progress.txt` before starting\n- Read the relevant CLAUDE.md for the target repo if it exists\n';
+
+// src/templates/embedded/skills-ralph.ts
+var RALPH_SKILL = '# Ralph - Plan Generator\n\nGenerate a structured implementation plan from a feature description.\n\n---\n\n## The Job\n\n1. Read the project configuration from `ralph.config.json`\n2. Analyze the user\'s feature request\n3. Ask 3-5 clarifying questions to understand scope\n4. Generate a detailed plan in `plan.md`\n5. Offer to validate or modify the plan\n\n---\n\n## Step 1: Read Configuration\n\nFirst, read `ralph.config.json` to understand:\n- Project name and description\n- Available repositories and their paths\n- Quality checks for each repository\n\nIf `ralph.config.json` doesn\'t exist, ask the user to create one or offer to generate a default configuration.\n\n---\n\n## Step 2: Clarifying Questions\n\nAsk 3-5 essential questions to understand the feature. Format questions with lettered options:\n\n```\n1. What is the primary goal of this feature?\n   A) Add new functionality\n   B) Improve existing functionality\n   C) Fix a bug\n   D) Refactor/cleanup\n\n2. Which parts of the codebase will be affected?\n   A) Backend only\n   B) Frontend only\n   C) Both backend and frontend\n   D) Other (specify)\n\n3. Are there any external dependencies required?\n   A) No new dependencies\n   B) Yes (specify which)\n```\n\nWait for the user to respond with format like "1A, 2C, 3A" before proceeding.\n\n---\n\n## Step 3: Generate Plan\n\nBased on the answers, generate `plan.md` with this structure:\n\n```markdown\n# [Project Name] - [Feature Name]\n\n[Brief description of the feature]\n\n---\n\n## Summary\n\n[2-3 sentences explaining what this plan accomplishes]\n\n---\n\n## User Stories\n\n### [Repository 1] Stories\n\n#### US-001: [Title]\n**Repository:** `repo-name`\n**Description:** As a [role], I want [feature] so that [benefit].\n\n**Acceptance Criteria:**\n- [ ] Specific, verifiable criterion\n- [ ] Another criterion\n- [ ] Tests pass (pytest/npm test/etc.)\n\n[Repeat for each story...]\n\n---\n\n## Technical Considerations\n\n- [Architecture decisions]\n- [Dependencies]\n- [Breaking changes]\n\n---\n\n## Open Questions\n\n- [Any unresolved questions]\n```\n\n---\n\n## Step 4: Story Guidelines\n\n### Story Size\n- Each story must be completable in ONE Claude Code iteration\n- If it can\'t be described in 2-3 sentences, split it\n- Rule: One story = One focused change in ONE repository\n\n### Story Order\nStories should be ordered by dependency:\n1. Database/schema changes first\n2. API/backend logic second\n3. Frontend components third\n4. Integration/polish last\n\n### Acceptance Criteria Rules\n- Must be objectively verifiable (not "works well" or "good UX")\n- Backend stories MUST include: "Tests pass"\n- Frontend stories MUST include: "Build passes" AND "Verify in browser"\n- Include specific checks relevant to the change\n\n---\n\n## Step 5: Validation\n\nAfter generating the plan, present it to the user and ask:\n\n```\nPlan generated and saved to `plan.md`.\n\nWould you like to:\nA) Validate and proceed to PRD generation (/prd)\nB) Make modifications (describe what to change)\nC) Start over with different requirements\n```\n\nIf user chooses B, make the requested modifications and re-validate.\n\n---\n\n## Output\n\n**File:** `plan.md`\n\nThe plan file will be used by the `/prd` command to generate the executable `prd.json`.\n\n---\n\n## Example Usage\n\nUser: `/ralph Add user authentication with OAuth`\n';
+
+// src/commands/plan.ts
+async function planCommand(feature, options = {}) {
+  const cwd = process.cwd();
+  const outputPath = options.output ?? path7.join(cwd, "plan.md");
+  checkClaudeInstalled();
+  let config;
+  try {
+    config = await loadConfig(cwd);
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      logger.warning("No configuration found. Run 'ralph init' first, or create ralph.config.json manually.");
+      logger.info("Continuing without configuration...");
+      config = null;
+    } else {
+      throw error;
+    }
+  }
+  logger.header("Ralph - Plan Generator");
+  logger.keyValue("Feature", feature);
+  if (config) {
+    logger.keyValue("Project", config.project);
+  }
+  logger.log("");
+  let prompt = RALPH_SKILL;
+  if (config) {
+    prompt += `
+
+## Current Configuration
+
+\`\`\`json
+${JSON.stringify(config, null, 2)}
+\`\`\``;
+  }
+  prompt += `
+
+## Feature Request
+
+${feature}`;
+  logger.info("Starting interactive plan generation...");
+  logger.info("Claude will ask clarifying questions. Please respond in the terminal.");
+  logger.log("");
+  const { execa: execa3 } = await import('execa');
+  const subprocess = execa3("claude", [`ultrathink ${prompt}`], {
+    cwd,
+    stdio: "inherit",
+    reject: false
+  });
+  await subprocess;
+  if (await fs7.pathExists(outputPath)) {
+    logger.log("");
+    logger.success(`Plan generated: ${outputPath}`);
+    logger.log("");
+    logger.log("Next steps:");
+    logger.log("  1. Review and edit plan.md if needed");
+    logger.log("  2. Run: ralph prd");
+    logger.log("  3. Run: ralph run");
+  } else {
+    logger.warning("Plan file was not created. You may need to re-run the command.");
+  }
+}
+var PrdNotFoundError = class extends Error {
+  constructor(filePath) {
+    super(
+      `PRD file not found: ${filePath}
+Run 'ralph plan <feature>' and 'ralph prd' to generate one.`
+    );
+    this.name = "PrdNotFoundError";
+  }
+};
+var PrdValidationError = class extends Error {
+  constructor(message) {
+    super(`Invalid PRD: ${message}`);
+    this.name = "PrdValidationError";
+  }
+};
+async function loadPrd(cwd = process.cwd()) {
+  const prdPath = path7.join(cwd, "prd.json");
+  if (!await fs7.pathExists(prdPath)) {
+    throw new PrdNotFoundError(prdPath);
+  }
+  const content = await fs7.readJSON(prdPath);
+  const parsed = PrdSchema.safeParse(content);
+  if (!parsed.success) {
+    throw new PrdValidationError(parsed.error.message);
+  }
+  return parsed.data;
+}
+async function savePrd(prd, cwd = process.cwd()) {
+  const prdPath = path7.join(cwd, "prd.json");
+  await fs7.writeJSON(prdPath, prd, { spaces: 2 });
+}
+async function prdExists(cwd = process.cwd()) {
+  const prdPath = path7.join(cwd, "prd.json");
+  return fs7.pathExists(prdPath);
+}
+function getPendingStories(prd) {
+  return prd.userStories.filter((story) => !story.passes).sort((a, b) => a.priority - b.priority);
+}
+function isAllComplete(prd) {
+  return prd.userStories.every((story) => story.passes);
+}
+function getStoriesByRepo(prd) {
+  const byRepo = {};
+  for (const story of prd.userStories) {
+    if (!byRepo[story.repo]) {
+      byRepo[story.repo] = [];
+    }
+    byRepo[story.repo].push(story);
+  }
+  return byRepo;
+}
+function getCompletionStats(prd) {
+  const total = prd.userStories.length;
+  const completed = prd.userStories.filter((s) => s.passes).length;
+  const pending = total - completed;
+  const percentage = total > 0 ? Math.round(completed / total * 100) : 0;
+  return { total, completed, pending, percentage };
+}
+
+// src/commands/prd.ts
+async function prdCommand(options = {}) {
+  const cwd = process.cwd();
+  const inputPath = options.input ?? path7.join(cwd, "plan.md");
+  const outputDir = options.output ? path7.dirname(options.output) : cwd;
+  if (!await fs7.pathExists(inputPath)) {
+    logger.error(`Plan file not found: ${inputPath}`);
+    logger.info("Run 'ralph plan <feature>' to generate a plan first.");
+    process.exit(1);
+  }
+  let config;
+  try {
+    config = await loadConfig(cwd);
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      logger.error("No configuration found. Run 'ralph init' first.");
+      process.exit(1);
+    }
+    throw error;
+  }
+  logger.header("Ralph - PRD Generator");
+  const planContent = await fs7.readFile(inputPath, "utf-8");
+  logger.info("Parsing plan.md...");
+  const prd = parsePlanToPrd(planContent, config);
+  await savePrd(prd, outputDir);
+  logger.log("");
+  logger.success("PRD Generated Successfully!");
+  logger.log("");
+  logger.keyValue("Project", prd.project);
+  logger.keyValue("Stories", prd.userStories.length.toString());
+  const byRepo = getStoriesByRepo(prd);
+  for (const [repo, stories] of Object.entries(byRepo)) {
+    logger.log(`  - ${repo}: ${stories.length} stories`);
+  }
+  logger.log("");
+  logger.log("Repositories:");
+  for (const [repo, info] of Object.entries(prd.repositories)) {
+    logger.log(`  - ${repo}: ${chalk4.cyan(info.branchName)}`);
+  }
+  logger.log("");
+  logger.log("Next steps:");
+  logger.log("  1. Review prd.json if needed");
+  logger.log("  2. Run: ralph run");
+}
+function parsePlanToPrd(content, config) {
+  const h1Match = content.match(/^#\s+(.+)$/m);
+  const projectName = h1Match ? h1Match[1].trim() : config.project;
+  const descMatch = content.match(/^#\s+.+\n\n(.+?)(?:\n\n|---)/s);
+  const description = descMatch ? descMatch[1].trim() : "";
+  const branchSlug = projectName.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").substring(0, 50);
+  const branchName = `feature/${branchSlug}`;
+  const stories = [];
+  const storyRegex = /####\s+(US-\d+):\s*(.+?)(?:\n|$)/g;
+  let match;
+  let priority = 1;
+  while ((match = storyRegex.exec(content)) !== null) {
+    const id = match[1];
+    const title = match[2].trim();
+    const storyStart = match.index;
+    const nextStoryMatch = content.slice(storyStart + match[0].length).match(/####\s+US-\d+/);
+    const storyEnd = nextStoryMatch ? storyStart + match[0].length + nextStoryMatch.index : content.length;
+    const storyContent = content.slice(storyStart, storyEnd);
+    const repoMatch = storyContent.match(/\*\*Repository:\*\*\s*`?(\w+)`?/);
+    const repo = repoMatch ? repoMatch[1] : "main";
+    const descMatch2 = storyContent.match(/\*\*Description:\*\*\s*(.+?)(?:\n\n|\*\*)/s);
+    const storyDesc = descMatch2 ? descMatch2[1].trim() : title;
+    const criteriaMatch = storyContent.match(/\*\*Acceptance Criteria:\*\*\s*([\s\S]*?)(?:\n\n---|\n\n####|$)/);
+    const criteria = [];
+    if (criteriaMatch) {
+      const criteriaLines = criteriaMatch[1].split("\n");
+      for (const line of criteriaLines) {
+        const item = line.replace(/^-\s*\[.\]\s*/, "").replace(/^-\s*/, "").trim();
+        if (item) {
+          criteria.push(item);
+        }
+      }
+    }
+    const isFork = storyContent.toLowerCase().includes("experimental") || storyContent.toLowerCase().includes("fork");
+    stories.push({
+      id,
+      title,
+      repo,
+      description: storyDesc,
+      acceptanceCriteria: criteria.length > 0 ? criteria : ["Implementation complete"],
+      priority: priority++,
+      passes: false,
+      fork: isFork,
+      notes: ""
+    });
+  }
+  const repositories = {};
+  const repoKeys = new Set(stories.map((s) => s.repo));
+  for (const repoKey of repoKeys) {
+    repositories[repoKey] = { branchName };
+  }
+  for (const repoKey of Object.keys(config.repositories)) {
+    if (!repositories[repoKey]) {
+      repositories[repoKey] = { branchName };
+    }
+  }
+  return {
+    project: projectName,
+    description,
+    repositories,
+    userStories: stories
+  };
+}
+var PROGRESS_FILE = "progress.txt";
+async function initProgressFile(projectName, cwd = process.cwd()) {
+  const progressPath = path7.join(cwd, PROGRESS_FILE);
+  if (await fs7.pathExists(progressPath)) {
+    return;
+  }
+  const content = `# Ralph Progress Log
+
+Project: ${projectName}
+Started: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Codebase Patterns
+
+(Add discovered patterns here as you work)
+
+---
+
+`;
+  await fs7.writeFile(progressPath, content);
+}
+async function progressExists(cwd = process.cwd()) {
+  const progressPath = path7.join(cwd, PROGRESS_FILE);
+  return fs7.pathExists(progressPath);
+}
+async function readProgress(cwd = process.cwd()) {
+  const progressPath = path7.join(cwd, PROGRESS_FILE);
+  if (!await fs7.pathExists(progressPath)) {
+    return "";
+  }
+  return fs7.readFile(progressPath, "utf-8");
+}
+async function getRecentProgress(lines = 50, cwd = process.cwd()) {
+  const content = await readProgress(cwd);
+  const allLines = content.split("\n");
+  return allLines.slice(-lines).join("\n");
+}
+async function isGitRepo(dir) {
+  const gitDir = path7.join(dir, ".git");
+  return fs7.pathExists(gitDir);
+}
+async function getCurrentBranch(cwd) {
+  if (!await isGitRepo(cwd)) {
+    return null;
+  }
+  const result = await run("git", ["branch", "--show-current"], { cwd });
+  if (result.exitCode !== 0) {
+    return null;
+  }
+  return result.stdout.trim() || "detached";
+}
+
+// src/commands/run.ts
+var COMPLETE_SIGNAL = "<promise>COMPLETE</promise>";
+var ARCHIVE_DIR = "archive";
+var LAST_PROJECT_FILE = ".last-project";
+async function runCommand(options = {}) {
+  const cwd = process.cwd();
+  checkClaudeInstalled();
+  let config;
+  try {
+    config = await loadConfig(cwd);
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      logger.error("No configuration found. Run 'ralph init' first.");
+      process.exit(1);
+    }
+    throw error;
+  }
+  if (!await prdExists(cwd)) {
+    logger.error("PRD file not found.");
+    logger.info("Run 'ralph plan <feature>' and 'ralph prd' to generate one.");
+    process.exit(1);
+  }
+  const prd = await loadPrd(cwd);
+  const maxIterations = options.maxIterations ?? config.agent?.maxIterations ?? 50;
+  await handleProjectArchive(cwd, prd.project);
+  await initProgressFile(prd.project, cwd);
+  showStatus(config, prd, maxIterations, cwd);
+  if (isAllComplete(prd)) {
+    logger.success("All stories already completed!");
+    return;
+  }
+  await runLoop(maxIterations, cwd);
+}
+async function handleProjectArchive(cwd, currentProject) {
+  const lastProjectPath = path7.join(cwd, LAST_PROJECT_FILE);
+  const prdPath = path7.join(cwd, "prd.json");
+  const progressPath = path7.join(cwd, "progress.txt");
+  if (await fs7.pathExists(lastProjectPath)) {
+    const lastProject = (await fs7.readFile(lastProjectPath, "utf-8")).trim();
+    if (lastProject && lastProject !== currentProject) {
+      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const folderName = lastProject.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+      const archivePath = path7.join(cwd, ARCHIVE_DIR, `${date}-${folderName}`);
+      logger.info(`Archiving previous run: ${lastProject}`);
+      await fs7.ensureDir(archivePath);
+      if (await fs7.pathExists(prdPath)) {
+        await fs7.copy(prdPath, path7.join(archivePath, "prd.json"));
+      }
+      if (await fs7.pathExists(progressPath)) {
+        await fs7.copy(progressPath, path7.join(archivePath, "progress.txt"));
+        await fs7.remove(progressPath);
+      }
+      logger.success(`Archived to: ${archivePath}`);
+    }
+  }
+  await fs7.writeFile(lastProjectPath, currentProject);
+}
+async function showStatus(config, prd, maxIterations, cwd) {
+  logger.header("Ralph - Autonomous Agent Loop");
+  logger.keyValue("Project", prd.project);
+  logger.keyValue("Max iterations", maxIterations.toString());
+  logger.log("");
+  logger.log("Repositories:");
+  for (const [repoKey, repoConfig] of Object.entries(config.repositories)) {
+    const repoPath = path7.resolve(cwd, repoConfig.path);
+    const branch = await getCurrentBranch(repoPath);
+    const branchInfo = branch ?? "(not a git repo)";
+    logger.log(`  - ${repoKey}: ${repoConfig.path} (${branchInfo})`);
+  }
+  logger.log("");
+  const pending = getPendingStories(prd);
+  if (pending.length > 0) {
+    logger.log("Pending stories:");
+    for (const story of pending) {
+      const forkTag = story.fork ? " (FORK)" : "";
+      logger.log(`  - ${story.id} [${story.repo}]${forkTag}: ${story.title}`);
+    }
+    logger.log("");
+  }
+}
+async function runLoop(maxIterations, cwd) {
+  for (let i = 1; i <= maxIterations; i++) {
+    logger.log("");
+    logger.log(chalk4.bold("========================================"));
+    logger.log(chalk4.bold(`  Iteration ${i} of ${maxIterations}`));
+    logger.log(chalk4.bold("========================================"));
+    logger.info("Starting Claude Code iteration...");
+    const output = await invokeClaudeStreaming(PROMPT_TEMPLATE, {
+      print: false,
+      // Must be false to allow Claude to execute tools
+      skipPermissions: true,
+      cwd
+    });
+    if (output.includes(COMPLETE_SIGNAL)) {
+      logger.log("");
+      logger.log(chalk4.bold("========================================"));
+      logger.success("Ralph completed all tasks!");
+      logger.log(`  Completed at iteration ${i} of ${maxIterations}`);
+      logger.log(chalk4.bold("========================================"));
+      logger.log("");
+      await showFinalBranchStatus(cwd);
+      return;
+    }
+    logger.info(`Iteration ${i} complete. Continuing...`);
+    await sleep(2e3);
+  }
+  logger.log("");
+  logger.warning(`Ralph reached max iterations (${maxIterations}) without completing all tasks.`);
+  logger.info("Check progress.txt for status.");
+  const prd = await loadPrd(cwd);
+  const pending = getPendingStories(prd);
+  if (pending.length > 0) {
+    logger.log("");
+    logger.log("Remaining stories:");
+    for (const story of pending) {
+      const forkTag = story.fork ? " (FORK)" : "";
+      logger.log(`  - ${story.id} [${story.repo}]${forkTag}: ${story.title}`);
+    }
+  }
+  process.exit(1);
+}
+async function showFinalBranchStatus(cwd) {
+  try {
+    const config = await loadConfig(cwd);
+    logger.log("Final branch status:");
+    for (const [repoKey, repoConfig] of Object.entries(config.repositories)) {
+      const repoPath = path7.resolve(cwd, repoConfig.path);
+      const branch = await getCurrentBranch(repoPath);
+      if (branch) {
+        logger.log(`  - ${repoKey}: ${branch}`);
+      }
+    }
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function statusCommand(options = {}) {
+  const cwd = process.cwd();
+  logger.header("Ralph - Status");
+  let config;
+  try {
+    config = await loadConfig(cwd);
+    logger.keyValue("Project", config.project);
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      logger.warning("No configuration found. Run 'ralph init' first.");
+      return;
+    }
+    throw error;
+  }
+  if (!await prdExists(cwd)) {
+    logger.warning("No PRD found. Run 'ralph plan <feature>' and 'ralph prd' first.");
+    return;
+  }
+  const prd = await loadPrd(cwd);
+  const stats = getCompletionStats(prd);
+  logger.log("");
+  logger.log(chalk4.bold("Progress:"));
+  const progressBar = createProgressBar(stats.percentage);
+  logger.log(`  ${progressBar} ${stats.percentage}%`);
+  logger.log(`  ${chalk4.green(stats.completed.toString())} completed / ${chalk4.yellow(stats.pending.toString())} pending / ${stats.total} total`);
+  logger.log("");
+  logger.log(chalk4.bold("Repositories:"));
+  for (const [repoKey, repoConfig] of Object.entries(config.repositories)) {
+    const repoPath = path7.resolve(cwd, repoConfig.path);
+    const branch = await getCurrentBranch(repoPath);
+    const branchInfo = branch ? chalk4.cyan(branch) : chalk4.gray("(not a git repo)");
+    const prdBranch = prd.repositories[repoKey]?.branchName;
+    let branchDisplay = branchInfo;
+    if (prdBranch && branch && branch !== prdBranch) {
+      branchDisplay = `${branchInfo} ${chalk4.yellow(`(expected: ${prdBranch})`)}`;
+    }
+    logger.log(`  ${chalk4.bold(repoKey)}: ${repoConfig.path} [${branchDisplay}]`);
+  }
+  const pending = getPendingStories(prd);
+  if (pending.length > 0) {
+    logger.log("");
+    logger.log(chalk4.bold("Pending Stories:"));
+    for (const story of pending) {
+      const forkTag = story.fork ? chalk4.magenta(" [FORK]") : "";
+      logger.log(`  ${chalk4.yellow(story.id)} [${story.repo}]${forkTag}: ${story.title}`);
+    }
+  } else {
+    logger.log("");
+    logger.success("All stories completed!");
+  }
+  if (options.verbose) {
+    const byRepo = getStoriesByRepo(prd);
+    logger.log("");
+    logger.log(chalk4.bold("Stories by Repository:"));
+    for (const [repo, stories] of Object.entries(byRepo)) {
+      const completed = stories.filter((s) => s.passes).length;
+      logger.log(`  ${chalk4.bold(repo)}: ${completed}/${stories.length} completed`);
+      for (const story of stories) {
+        const status = story.passes ? chalk4.green("\u2713") : chalk4.yellow("\u25CB");
+        logger.log(`    ${status} ${story.id}: ${story.title}`);
+      }
+    }
+  }
+  if (options.verbose && await progressExists(cwd)) {
+    const recent = await getRecentProgress(10, cwd);
+    if (recent.trim()) {
+      logger.log("");
+      logger.log(chalk4.bold("Recent Progress:"));
+      logger.log(chalk4.gray(recent));
+    }
+  }
+}
+function createProgressBar(percentage, width = 20) {
+  const filled = Math.round(percentage / 100 * width);
+  const empty = width - filled;
+  const bar = chalk4.green("\u2588".repeat(filled)) + chalk4.gray("\u2591".repeat(empty));
+  return `[${bar}]`;
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("ralph").description("Autonomous AI agent loop for Claude Code").version("1.0.0");
+program.command("init").description("Initialize Ralph configuration in the current directory").option("-f, --force", "Overwrite existing configuration").action(async (options) => {
+  await initCommand(options);
+});
+program.command("plan <feature>").description("Generate a structured implementation plan").option("-o, --output <path>", "Output path for plan.md").action(async (feature, options) => {
+  await planCommand(feature, options);
+});
+program.command("prd").description("Convert plan.md into prd.json").option("-i, --input <path>", "Input path for plan.md").option("-o, --output <path>", "Output path for prd.json").action(async (options) => {
+  await prdCommand(options);
+});
+program.command("run").description("Run the autonomous agent loop").option("-m, --max-iterations <number>", "Maximum number of iterations", parseInt).action(async (options) => {
+  await runCommand({
+    maxIterations: options.maxIterations
+  });
+});
+program.command("status").description("Show current progress and status").option("-v, --verbose", "Show detailed information").action(async (options) => {
+  await statusCommand(options);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map