ralph-cli-claude 0.1.0

package/README.md

@@ -0,0 +1,149 @@
+# ralph-cli-claude
+
+AI-driven development automation CLI for [Claude Code](https://github.com/anthropics/claude-code).
+
+Ralph automates iterative development by having Claude work through a PRD (Product Requirements Document), implementing features one at a time, running tests, and committing changes.
+
+## Installation
+
+```bash
+# Use directly with npx
+npx ralph-cli-claude init
+
+# Or install globally
+npm install -g ralph-cli-claude
+ralph init
+```
+
+## Quick Start
+
+```bash
+# 1. Initialize ralph in your project
+ralph init
+
+# 2. Add requirements to your PRD
+ralph prd add
+
+# 3. Run a single iteration
+ralph once
+
+# 4. Or run multiple iterations
+ralph run 5
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `ralph init` | Initialize ralph in current project |
+| `ralph once` | Run a single automation iteration |
+| `ralph run <n>` | Run n automation iterations |
+| `ralph prd add` | Add a new PRD entry (interactive) |
+| `ralph prd list` | List all PRD entries |
+| `ralph prd status` | Show PRD completion status |
+| `ralph prd toggle <n>` | Toggle passes status for entry n |
+| `ralph scripts` | Generate shell scripts for sandboxed environments |
+| `ralph docker` | Generate Docker sandbox environment |
+| `ralph help` | Show help message |
+
+## Configuration
+
+After running `ralph init`, you'll have:
+
+```
+.ralph/
+├── config.json      # Project configuration
+├── prompt.md        # Shared prompt template
+├── prd.json         # Product requirements document
+└── progress.txt     # Progress tracking file
+```
+
+### Supported Languages
+
+- **Bun** (TypeScript) - `bun check`, `bun test`
+- **Node.js** (TypeScript) - `npm run typecheck`, `npm test`
+- **Python** - `mypy .`, `pytest`
+- **Go** - `go build ./...`, `go test ./...`
+- **Rust** - `cargo check`, `cargo test`
+- **Custom** - Define your own commands
+
+## PRD Format
+
+The PRD (`prd.json`) is an array of requirements:
+
+```json
+[
+  {
+    "category": "feature",
+    "description": "Add user authentication",
+    "steps": [
+      "Create login form",
+      "Implement JWT tokens",
+      "Add protected routes"
+    ],
+    "passes": false
+  }
+]
+```
+
+Categories: `ui`, `feature`, `bugfix`, `setup`, `development`, `testing`, `docs`
+
+## Docker Sandbox
+
+Run ralph in an isolated Docker container:
+
+```bash
+# Generate Docker files
+ralph docker
+
+# Build the image
+ralph docker --build
+
+# Run container
+ralph docker --run
+```
+
+Features:
+- Based on [Claude Code devcontainer](https://github.com/anthropics/claude-code/tree/main/.devcontainer)
+- Network sandboxing (firewall allows only GitHub, npm, Anthropic API)
+- Your `~/.claude` credentials mounted automatically (Pro/Max OAuth)
+- Language-specific tooling pre-installed
+
+### Installing packages in container
+
+```bash
+# Run as root to install packages
+docker compose run -u root ralph apt-get update
+docker compose run -u root ralph apt-get install <package>
+```
+
+## Shell Scripts
+
+For environments where the CLI isn't available:
+
+```bash
+ralph scripts
+```
+
+Generates `ralph.sh` and `ralph-once.sh` in your project root.
+
+## How It Works
+
+1. **Read PRD**: Claude reads your requirements from `prd.json`
+2. **Implement**: Works on the highest priority incomplete feature
+3. **Verify**: Runs your check and test commands
+4. **Update**: Marks the feature as complete in the PRD
+5. **Commit**: Creates a git commit for the feature
+6. **Repeat**: Continues to the next feature (in `run` mode)
+
+When all PRD items pass, Claude outputs `<promise>COMPLETE</promise>` and stops.
+
+## Requirements
+
+- Node.js 18+
+- [Claude Code CLI](https://github.com/anthropics/claude-code) installed
+- Claude Pro/Max subscription or Anthropic API key
+
+## License
+
+MIT

package/dist/commands/docker.d.ts

@@ -0,0 +1 @@
+export declare function docker(args: string[]): Promise<void>;

package/dist/commands/docker.js

@@ -0,0 +1,406 @@
+import { existsSync, writeFileSync, mkdirSync, chmodSync } from "fs";
+import { join, basename } from "path";
+import { spawn } from "child_process";
+import { loadConfig, getRalphDir } from "../utils/config.js";
+import { promptConfirm } from "../utils/prompt.js";
+const DOCKER_DIR = "docker";
+// Language-specific Dockerfile snippets
+const LANGUAGE_SNIPPETS = {
+    bun: `
+# Install Bun
+RUN curl -fsSL https://bun.sh/install | bash
+ENV PATH="/home/node/.bun/bin:$PATH"
+`,
+    node: `
+# Node.js already included in base image
+`,
+    python: `
+# Install Python and tools
+RUN apt-get update && apt-get install -y \\
+    python3 \\
+    python3-pip \\
+    python3-venv \\
+    && rm -rf /var/lib/apt/lists/*
+RUN pip3 install --break-system-packages mypy pytest
+`,
+    go: `
+# Install Go
+RUN curl -fsSL https://go.dev/dl/go1.22.0.linux-amd64.tar.gz | tar -C /usr/local -xzf -
+ENV PATH="/usr/local/go/bin:/home/node/go/bin:$PATH"
+ENV GOPATH="/home/node/go"
+`,
+    rust: `
+# Install Rust
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+ENV PATH="/home/node/.cargo/bin:$PATH"
+`,
+    none: `
+# Custom language - add your dependencies here
+`,
+};
+function generateDockerfile(language) {
+    const languageSnippet = LANGUAGE_SNIPPETS[language] || LANGUAGE_SNIPPETS.none;
+    return `# Ralph CLI Sandbox Environment
+# Based on Claude Code devcontainer
+# Generated by ralph-cli
+
+FROM node:20-bookworm
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG TZ=UTC
+ARG CLAUDE_CODE_VERSION="latest"
+ARG ZSH_IN_DOCKER_VERSION="1.2.1"
+
+# Set timezone
+ENV TZ=\${TZ}
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    git \\
+    curl \\
+    wget \\
+    nano \\
+    vim \\
+    less \\
+    procps \\
+    sudo \\
+    man-db \\
+    unzip \\
+    gnupg2 \\
+    jq \\
+    fzf \\
+    iptables \\
+    ipset \\
+    iproute2 \\
+    dnsutils \\
+    zsh \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Setup zsh with oh-my-zsh and plugins (no theme, we set custom prompt)
+RUN sh -c "$(wget -O- https://github.com/deluan/zsh-in-docker/releases/download/v\${ZSH_IN_DOCKER_VERSION}/zsh-in-docker.sh)" -- \\
+    -t "" \\
+    -p git \\
+    -p fzf \\
+    -a "source /usr/share/doc/fzf/examples/key-bindings.zsh 2>/dev/null || true" \\
+    -a "source /usr/share/doc/fzf/examples/completion.zsh 2>/dev/null || true" \\
+    -a "export HISTFILE=/commandhistory/.zsh_history" \\
+    -a 'alias ll="ls -la"'
+
+# Set custom prompt for node user (after oh-my-zsh to avoid override)
+RUN cp -r /root/.oh-my-zsh /home/node/.oh-my-zsh && chown -R node:node /home/node/.oh-my-zsh && \\
+    cp /root/.zshrc /home/node/.zshrc && chown node:node /home/node/.zshrc && \\
+    sed -i 's|/root/.oh-my-zsh|/home/node/.oh-my-zsh|g' /home/node/.zshrc && \\
+    echo 'PROMPT="%K{yellow}%F{black}[ralph]%f%k%K{yellow}%F{black}%d%f%k\\$ "' >> /home/node/.zshrc
+
+# Install Claude Code CLI
+RUN npm install -g @anthropic-ai/claude-code@\${CLAUDE_CODE_VERSION}
+
+# Install ralph-cli-claude
+RUN npm install -g ralph-cli-claude || echo "ralph-cli-claude not yet published, will use local"
+${languageSnippet}
+# Setup sudo only for firewall script (no general sudo for security)
+RUN echo "node ALL=(ALL) NOPASSWD: /usr/local/bin/init-firewall.sh" >> /etc/sudoers.d/node-firewall
+
+# Create directories
+RUN mkdir -p /workspace && chown node:node /workspace
+RUN mkdir -p /home/node/.claude && chown node:node /home/node/.claude
+RUN mkdir -p /commandhistory && chown node:node /commandhistory
+
+# Copy firewall script
+COPY init-firewall.sh /usr/local/bin/init-firewall.sh
+RUN chmod +x /usr/local/bin/init-firewall.sh
+
+# Set environment variables
+ENV DEVCONTAINER=true
+ENV NODE_OPTIONS="--max-old-space-size=4096"
+ENV CLAUDE_CONFIG_DIR="/home/node/.claude"
+ENV SHELL=/bin/zsh
+ENV EDITOR=nano
+
+# Add bash aliases and prompt (fallback if using bash)
+RUN echo 'alias ll="ls -la"' >> /etc/bash.bashrc && \\
+    echo 'PS1="\\[\\033[43;30m\\][ralph]\\w\\[\\033[0m\\]\\$ "' >> /etc/bash.bashrc
+
+# Switch to non-root user
+USER node
+WORKDIR /workspace
+
+# Default to zsh
+CMD ["zsh"]
+`;
+}
+const FIREWALL_SCRIPT = `#!/bin/bash
+# Firewall initialization script for Ralph sandbox
+# Based on Claude Code devcontainer firewall
+
+set -e
+
+echo "Initializing sandbox firewall..."
+
+# Get Docker DNS before flushing
+DOCKER_DNS=$(cat /etc/resolv.conf | grep nameserver | head -1 | awk '{print $2}')
+
+# Flush existing rules
+iptables -F
+iptables -X
+iptables -t nat -F
+iptables -t nat -X
+iptables -t mangle -F
+iptables -t mangle -X
+
+# Create ipset for allowed IPs
+ipset destroy allowed_ips 2>/dev/null || true
+ipset create allowed_ips hash:net
+
+# Allow localhost
+iptables -A OUTPUT -o lo -j ACCEPT
+iptables -A INPUT -i lo -j ACCEPT
+
+# Allow established connections
+iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+
+# Allow DNS
+iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
+iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
+if [ -n "$DOCKER_DNS" ]; then
+    iptables -A OUTPUT -d $DOCKER_DNS -j ACCEPT
+fi
+
+# Allow SSH (for git)
+iptables -A OUTPUT -p tcp --dport 22 -j ACCEPT
+
+# Add allowed domains to ipset
+# GitHub
+for ip in $(dig +short github.com api.github.com raw.githubusercontent.com); do
+    ipset add allowed_ips $ip 2>/dev/null || true
+done
+
+# npm registry
+for ip in $(dig +short registry.npmjs.org); do
+    ipset add allowed_ips $ip 2>/dev/null || true
+done
+
+# Anthropic API
+for ip in $(dig +short api.anthropic.com); do
+    ipset add allowed_ips $ip 2>/dev/null || true
+done
+
+# Allow host network (for mounted volumes, etc.)
+HOST_NETWORK=$(ip route | grep default | awk '{print $3}' | head -1)
+if [ -n "$HOST_NETWORK" ]; then
+    HOST_SUBNET=$(echo $HOST_NETWORK | sed 's/\\.[0-9]*$/.0\\/24/')
+    ipset add allowed_ips $HOST_SUBNET 2>/dev/null || true
+fi
+
+# Allow traffic to allowed IPs
+iptables -A OUTPUT -m set --match-set allowed_ips dst -j ACCEPT
+
+# Set default policies to DROP
+iptables -P INPUT DROP
+iptables -P FORWARD DROP
+iptables -P OUTPUT DROP
+
+# Allow HTTPS to allowed IPs
+iptables -I OUTPUT -p tcp --dport 443 -m set --match-set allowed_ips dst -j ACCEPT
+iptables -I OUTPUT -p tcp --dport 80 -m set --match-set allowed_ips dst -j ACCEPT
+
+echo "Firewall initialized. Only allowed destinations are accessible."
+echo "Allowed: GitHub, npm, Anthropic API, local network"
+`;
+function generateDockerCompose(imageName) {
+    return `# Ralph CLI Docker Compose
+# Generated by ralph-cli
+
+services:
+  ralph:
+    image: ${imageName}
+    build:
+      context: .
+      dockerfile: Dockerfile
+    volumes:
+      # Mount project root (two levels up from .ralph/docker/)
+      - ../..:/workspace
+      # Mount host's ~/.claude for Pro/Max OAuth credentials
+      - \${HOME}/.claude:/home/node/.claude
+      - ${imageName}-history:/commandhistory
+    # Uncomment to use API key instead of OAuth:
+    # environment:
+    #   - ANTHROPIC_API_KEY=\${ANTHROPIC_API_KEY}
+    working_dir: /workspace
+    stdin_open: true
+    tty: true
+    cap_add:
+      - NET_ADMIN  # Required for firewall
+    # Uncomment to enable firewall sandboxing:
+    # command: bash -c "sudo /usr/local/bin/init-firewall.sh && zsh"
+
+volumes:
+  ${imageName}-history:
+`;
+}
+const DOCKERIGNORE = `# Docker ignore file
+node_modules
+dist
+.git
+*.log
+`;
+async function generateFiles(ralphDir, language, imageName) {
+    const dockerDir = join(ralphDir, DOCKER_DIR);
+    // Create docker directory
+    if (!existsSync(dockerDir)) {
+        mkdirSync(dockerDir, { recursive: true });
+        console.log(`Created ${DOCKER_DIR}/`);
+    }
+    const files = [
+        { name: "Dockerfile", content: generateDockerfile(language) },
+        { name: "init-firewall.sh", content: FIREWALL_SCRIPT },
+        { name: "docker-compose.yml", content: generateDockerCompose(imageName) },
+        { name: ".dockerignore", content: DOCKERIGNORE },
+    ];
+    for (const file of files) {
+        const filePath = join(dockerDir, file.name);
+        if (existsSync(filePath)) {
+            const overwrite = await promptConfirm(`${DOCKER_DIR}/${file.name} already exists. Overwrite?`);
+            if (!overwrite) {
+                console.log(`Skipped ${file.name}`);
+                continue;
+            }
+        }
+        writeFileSync(filePath, file.content);
+        if (file.name.endsWith(".sh")) {
+            chmodSync(filePath, 0o755);
+        }
+        console.log(`Created ${DOCKER_DIR}/${file.name}`);
+    }
+}
+async function buildImage(ralphDir) {
+    const dockerDir = join(ralphDir, DOCKER_DIR);
+    if (!existsSync(join(dockerDir, "Dockerfile"))) {
+        console.error("Dockerfile not found. Run 'ralph docker' first.");
+        process.exit(1);
+    }
+    console.log("Building Docker image...\n");
+    return new Promise((resolve, reject) => {
+        const proc = spawn("docker", ["compose", "build"], {
+            cwd: dockerDir,
+            stdio: "inherit",
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                console.log("\nDocker image built successfully!");
+                resolve();
+            }
+            else {
+                reject(new Error(`Docker build failed with code ${code}`));
+            }
+        });
+        proc.on("error", (err) => {
+            reject(new Error(`Failed to run docker: ${err.message}`));
+        });
+    });
+}
+async function runContainer(ralphDir) {
+    const dockerDir = join(ralphDir, DOCKER_DIR);
+    if (!existsSync(join(dockerDir, "Dockerfile"))) {
+        console.error("Dockerfile not found. Run 'ralph docker' first.");
+        process.exit(1);
+    }
+    console.log("Starting Docker container...\n");
+    return new Promise((resolve, reject) => {
+        const proc = spawn("docker", ["compose", "run", "--rm", "ralph"], {
+            cwd: dockerDir,
+            stdio: "inherit",
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Docker run failed with code ${code}`));
+            }
+        });
+        proc.on("error", (err) => {
+            reject(new Error(`Failed to run docker: ${err.message}`));
+        });
+    });
+}
+export async function docker(args) {
+    const flag = args[0];
+    // Show help without requiring init
+    if (flag === "--help" || flag === "-h") {
+        console.log(`
+ralph docker - Generate and manage Docker sandbox environment
+
+USAGE:
+  ralph docker              Generate Dockerfile and scripts
+  ralph docker --build      Build the Docker image
+  ralph docker --run        Run container with project mounted
+
+FILES GENERATED:
+  .ralph/docker/
+  ├── Dockerfile            Based on Claude Code devcontainer
+  ├── init-firewall.sh      Sandbox firewall script
+  ├── docker-compose.yml    Container orchestration
+  └── .dockerignore         Build exclusions
+
+AUTHENTICATION:
+  Pro/Max users: Your ~/.claude credentials are mounted automatically.
+  API key users: Uncomment ANTHROPIC_API_KEY in docker-compose.yml.
+
+EXAMPLES:
+  ralph docker                      # Generate files
+  ralph docker --build              # Build image
+  ralph docker --run                # Start interactive shell
+
+  # Or use docker compose directly:
+  cd .ralph/docker && docker compose run --rm ralph
+
+  # Run ralph automation in container:
+  docker compose run --rm ralph ralph once
+
+INSTALLING PACKAGES (works with Docker & Podman):
+  # 1. Run as root to install packages:
+  docker compose run -u root ralph apt-get update
+  docker compose run -u root ralph apt-get install <package>
+
+  # 2. Or commit changes to a new image:
+  docker run -it --name temp -u root <image> bash
+  # inside: apt-get update && apt-get install <package>
+  # exit, then:
+  docker commit temp <image>:custom
+  docker rm temp
+`);
+        return;
+    }
+    const ralphDir = getRalphDir();
+    if (!existsSync(ralphDir)) {
+        console.error("Error: .ralph/ directory not found. Run 'ralph init' first.");
+        process.exit(1);
+    }
+    const config = loadConfig();
+    // Get image name from config or generate default
+    const imageName = config.imageName || `ralph-${basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
+    if (flag === "--build") {
+        await buildImage(ralphDir);
+    }
+    else if (flag === "--run") {
+        await runContainer(ralphDir);
+    }
+    else {
+        console.log(`Generating Docker files for: ${config.language}`);
+        console.log(`Image name: ${imageName}\n`);
+        await generateFiles(ralphDir, config.language, imageName);
+        console.log(`
+Docker files generated in .ralph/docker/
+
+Next steps:
+  1. Build the image: ralph docker --build
+  2. Run container:    ralph docker --run
+
+Or use docker compose directly:
+  cd .ralph/docker && docker compose run --rm ralph
+`);
+    }
+}

package/dist/commands/help.d.ts

@@ -0,0 +1 @@
+export declare function help(_args: string[]): void;

package/dist/commands/help.js

@@ -0,0 +1,44 @@
+const HELP_TEXT = `
+ralph - AI-driven development automation CLI
+
+USAGE:
+  ralph <command> [options]
+
+COMMANDS:
+  init              Initialize ralph in current project
+  once              Run a single automation iteration
+  run <n>           Run n automation iterations
+  prd <subcommand>  Manage PRD entries
+  scripts           Generate shell scripts (for sandboxed environments)
+  docker            Generate Docker sandbox environment
+  help              Show this help message
+
+PRD SUBCOMMANDS:
+  prd add           Add a new PRD entry (interactive)
+  prd list          List all PRD entries
+  prd status        Show PRD completion status
+  prd toggle <n>    Toggle passes status for entry n
+
+EXAMPLES:
+  ralph init                 # Initialize ralph for your project
+  ralph once                 # Run single iteration
+  ralph run 5                # Run 5 iterations
+  ralph prd add              # Add new PRD entry
+  ralph prd list             # Show all entries
+  ralph prd status           # Show completion summary
+  ralph scripts              # Generate ralph.sh and ralph-once.sh
+  ralph docker               # Generate Dockerfile for sandboxed env
+  ralph docker --build       # Build Docker image
+  ralph docker --run         # Run container interactively
+
+CONFIGURATION:
+  After running 'ralph init', you'll have:
+  .ralph/
+  ├── config.json      Project configuration
+  ├── prompt.md        Shared prompt template
+  ├── prd.json         Product requirements document
+  └── progress.txt     Progress tracking file
+`;
+export function help(_args) {
+    console.log(HELP_TEXT.trim());
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(_args: string[]): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,98 @@
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { join, basename } from "path";
+import { LANGUAGES, generatePrompt, DEFAULT_PRD, DEFAULT_PROGRESS } from "../templates/prompts.js";
+import { promptSelect, promptConfirm, promptInput } from "../utils/prompt.js";
+const RALPH_DIR = ".ralph";
+const CONFIG_FILE = "config.json";
+const PROMPT_FILE = "prompt.md";
+const PRD_FILE = "prd.json";
+const PROGRESS_FILE = "progress.txt";
+export async function init(_args) {
+    const cwd = process.cwd();
+    const ralphDir = join(cwd, RALPH_DIR);
+    console.log("Initializing ralph in current directory...\n");
+    // Check for existing .ralph directory
+    if (existsSync(ralphDir)) {
+        const reinit = await promptConfirm(".ralph/ directory already exists. Re-initialize?");
+        if (!reinit) {
+            console.log("Aborted.");
+            return;
+        }
+    }
+    else {
+        mkdirSync(ralphDir, { recursive: true });
+        console.log(`Created ${RALPH_DIR}/`);
+    }
+    // Select language
+    const languageKeys = Object.keys(LANGUAGES);
+    const languageNames = languageKeys.map(k => `${LANGUAGES[k].name} - ${LANGUAGES[k].description}`);
+    const selectedName = await promptSelect("Select your project language/runtime:", languageNames);
+    const selectedIndex = languageNames.indexOf(selectedName);
+    const selectedKey = languageKeys[selectedIndex];
+    const config = LANGUAGES[selectedKey];
+    // Allow custom commands
+    let checkCommand = config.checkCommand;
+    let testCommand = config.testCommand;
+    if (selectedKey === "none") {
+        checkCommand = await promptInput("\nEnter your type/build check command: ") || checkCommand;
+        testCommand = await promptInput("Enter your test command: ") || testCommand;
+    }
+    const finalConfig = {
+        ...config,
+        checkCommand,
+        testCommand,
+    };
+    // Generate image name from directory name
+    const projectName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    const imageName = `ralph-${projectName}`;
+    // Write config file
+    const configData = {
+        language: selectedKey,
+        checkCommand: finalConfig.checkCommand,
+        testCommand: finalConfig.testCommand,
+        imageName,
+    };
+    const configPath = join(ralphDir, CONFIG_FILE);
+    writeFileSync(configPath, JSON.stringify(configData, null, 2) + "\n");
+    console.log(`\nCreated ${RALPH_DIR}/${CONFIG_FILE}`);
+    // Write prompt file (ask if exists)
+    const prompt = generatePrompt(finalConfig);
+    const promptPath = join(ralphDir, PROMPT_FILE);
+    if (existsSync(promptPath)) {
+        const overwritePrompt = await promptConfirm(`${RALPH_DIR}/${PROMPT_FILE} already exists. Overwrite?`);
+        if (overwritePrompt) {
+            writeFileSync(promptPath, prompt + "\n");
+            console.log(`Updated ${RALPH_DIR}/${PROMPT_FILE}`);
+        }
+        else {
+            console.log(`Skipped ${RALPH_DIR}/${PROMPT_FILE}`);
+        }
+    }
+    else {
+        writeFileSync(promptPath, prompt + "\n");
+        console.log(`Created ${RALPH_DIR}/${PROMPT_FILE}`);
+    }
+    // Create PRD if not exists
+    const prdPath = join(ralphDir, PRD_FILE);
+    if (!existsSync(prdPath)) {
+        writeFileSync(prdPath, DEFAULT_PRD + "\n");
+        console.log(`Created ${RALPH_DIR}/${PRD_FILE}`);
+    }
+    else {
+        console.log(`Skipped ${RALPH_DIR}/${PRD_FILE} (already exists)`);
+    }
+    // Create progress file if not exists
+    const progressPath = join(ralphDir, PROGRESS_FILE);
+    if (!existsSync(progressPath)) {
+        writeFileSync(progressPath, DEFAULT_PROGRESS);
+        console.log(`Created ${RALPH_DIR}/${PROGRESS_FILE}`);
+    }
+    else {
+        console.log(`Skipped ${RALPH_DIR}/${PROGRESS_FILE} (already exists)`);
+    }
+    console.log("\nRalph initialized successfully!");
+    console.log("\nNext steps:");
+    console.log("  1. Edit .ralph/prd.json to add your project requirements");
+    console.log("  2. Run 'ralph once' to start the first iteration");
+    console.log("  3. Or run 'ralph run 5' for 5 automated iterations");
+}