vibepup 1.0.0

package/PUBLISHING.md

@@ -0,0 +1,22 @@
+# Vibepup npm Publishing (from any machine)
+
+## 1) Login
+```bash
+npm adduser
+```
+
+## 2) Verify package metadata
+```bash
+node -p "require('./package.json').name"
+node -p "require('./package.json').version"
+```
+
+## 3) Publish
+```bash
+npm publish --access public
+```
+
+## Notes
+- Publish must be run inside `npm-package/`.
+- If you see a `bin` warning, ensure `package.json` has: `"bin": "bin/ralph.js"`.
+- Windows users should have Git Bash or WSL installed to run the CLI.

package/README.md

@@ -0,0 +1,103 @@
+# 🐾 Vibepup
+
+> **"Fetch Code. Sit. Stay. Good Pup."**
+
+Vibepup is a **Split-Brain Autonomous Agent Harness** that lives in your terminal. A loyal helper built for **DX-first, vibe-coding energy**.
+
+**Mascot:** Pummy the cyberpunk corgi.
+
+![Pummy Loop](https://raw.githubusercontent.com/shantanusoam/ralph-project/refs/heads/gh-images/assets/corgi_Loop.png)
+
+[![npm version](https://badge.fury.io/js/vibepup.svg)](https://badge.fury.io/js/vibepup)
+![License](https://img.shields.io/npm/l/vibepup)
+
+## ✨ The Vibe
+Most AI agents are black boxes that overwrite your files and get stuck in loops. Vibepup is different: loyal, friendly, meme-y, and built for real dev workflows.
+
+**Selling Points:**
+- DX-first onboarding
+- Vibe-coding friendly
+- Safe, loop-resistant agent harness
+- Minimal setup, works everywhere
+- Loyal helper with a cyberpunk-cute mascot
+
+*   **🧠 Split-Brain**: Keeps your instructions (`prd.md`) separate from internal state (`prd.state.json`). Edit tasks mid-run without breaking the agent.
+*   **🛡️ Anti-Wizard**: Refuses to run interactive commands that hang shells. Vibepup forces clarity.
+*   **⚡ DX-First**: Optimized for fast iteration, visibility, and zero-friction adoption.
+*   **🌈 Cyberpunk Corgi**: Cute, loyal, and ready to ship.
+*   **🧩 Friendly + Meme-y**: The tool feels fun without being unserious.
+
+![Pummy Checklist](https://raw.githubusercontent.com/shantanusoam/ralph-project/refs/heads/gh-images/assets/corgi_checklist.png)
+
+## 🚀 Get Started
+
+### ✅ Works Everywhere
+Linux, macOS, and Windows (via Git Bash or WSL). Vibepup is portable and requires only Bash + `opencode`.
+
+### 1. Install
+```bash
+npm install -g vibepup
+```
+
+### 1b. bunx (no global install)
+```bash
+bunx vibepup --watch
+```
+
+### 1c. bun global install (optional)
+```bash
+bun add -g vibepup
+```
+
+### 2. Fetch!
+Go to any empty folder and tell Vibepup what to build.
+
+```bash
+mkdir my-app
+cd my-app
+vibepup new "A react app for tracking my plant watering schedule"
+```
+
+Using bunx:
+```bash
+bunx vibepup new "A react app for tracking my plant watering schedule"
+```
+
+Using bun global install:
+```bash
+vibepup new "A react app for tracking my plant watering schedule"
+```
+
+Vibepup will:
+1.  🏗️ **Plan**: Map out the architecture in `repo-map.md`.
+2.  📝 **Draft**: Create a `prd.md` checklist.
+3.  🔨 **Build**: Start checking off items one by one.
+
+### 3. Watch Him Work
+```bash
+vibepup --watch
+```
+In watch mode, Vibepup keeps working until the PRD is done. If you edit `prd.md` (e.g., add "- [ ] Add dark mode"), he smells the change and gets back to work immediately.
+
+## ⚙️ Configuration
+Vibepup works out of the box, but you can tune his brain in `~/.config/ralph/config.json`:
+
+```json
+{
+  "build_models": [
+    "github-copilot/gpt-5.2-codex",
+    "openai/gpt-4o"
+  ],
+  "plan_models": [
+    "github-copilot/claude-opus-4.5"
+  ]
+}
+```
+
+## 🏗️ Architecture
+*   **Plan Mode**: When `repo-map.md` is missing, Vibepup explores and plans.
+*   **Build Mode**: When `repo-map.md` exists, Vibepup executes tasks from `prd.md`.
+
+
+## License
+MIT

package/bin/ralph.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const scriptPath = path.join(__dirname, '../lib/ralph.sh');
+const args = process.argv.slice(2);
+
+try {
+  fs.chmodSync(scriptPath, '755');
+} catch (err) {}
+
+console.log('🐾 Vibepup is waking up...');
+
+let command = scriptPath;
+let cmdArgs = args;
+let shellOptions = { stdio: 'inherit', shell: false };
+
+if (os.platform() === 'win32') {
+    command = 'bash';
+    cmdArgs = [scriptPath, ...args];
+    shellOptions.shell = true;
+} else {
+    command = 'bash';
+    cmdArgs = [scriptPath, ...args];
+}
+
+const vibepup = spawn(command, cmdArgs, shellOptions);
+
+vibepup.on('error', (err) => {
+    console.error('❌ Failed to start Vibepup.');
+    if (err.code === 'ENOENT') {
+        console.error('   Error: Bash not found. Please install Git Bash or WSL.');
+    } else {
+        console.error(String(err));
+    }
+    process.exit(1);
+});
+
+vibepup.on('close', (code) => {
+    process.exit(code);
+});

package/lib/agents/architect.md

@@ -0,0 +1,32 @@
+# Identity
+You are **The Architect**, a Phase 0 initialization agent for the Ralph system.
+Your goal is to take a raw, abstract project "Idea" and convert it into a concrete, actionable engineering plan.
+
+# Output Deliverables
+You must use the `write` tool to generate the following three files in the current directory:
+
+1. **`prd.json`**
+   - A JSON file containing a list of atomic tasks.
+   - Format: `[ { "id": "1", "description": "...", "status": "pending" } ]`
+   - Break the project down into 5-10 high-level implementation steps.
+   - **Crucial**: The first step must always be "Initialize project scaffold and install dependencies".
+
+2. **`repo-map.md`**
+   - A markdown file describing the intended file structure.
+   - Use a tree-like format or a bulleted list.
+   - This prevents the "Build" agents from flying blind.
+
+3. **`README.md`**
+   - A high-level overview of the project, its purpose, and the chosen tech stack.
+
+# Tech Stack defaults (Unless specified otherwise)
+- **Web/Frontend**: React, Next.js (App Router), TailwindCSS, Shadcn/UI.
+- **Backend/API**: Python (FastAPI) or Go (Chi/Gin).
+- **CLI**: Go (Cobra) or Python (Click).
+- **Database**: SQLite (for simple), PostgreSQL (for complex).
+
+# Instructions
+1. Analyze the user's "Idea".
+2. Determine the best architecture and stack.
+3. **WRITE** the files (`prd.json`, `repo-map.md`, `README.md`).
+4. Do not ask for confirmation. Just build the plan.

package/lib/agents/reviewer.md

@@ -0,0 +1,19 @@
+# Ralph - Code Reviewer Agent
+
+You are a senior code reviewer. Your goal is to review the changes made by the primary agent *before* they are committed.
+
+## Context
+- `diff.patch`: The changes proposed by the primary agent.
+- `prd.json`: The task requirements.
+- `repo-map.md`: Architecture context.
+
+## Your Job
+1.  **Analyze the Diff**: Look for bugs, security issues, performance problems, and style violations.
+2.  **Verify Against PRD**: Did the code actually implement what was asked?
+3.  **Check for "Context Burn"**: Did the agent delete critical comments or modify unrelated files?
+
+## Output
+- If the code is good: Output `<review>PASS</review>`.
+- If there are issues:
+    - Write a concise list of required fixes to `review-feedback.txt`.
+    - Output `<review>FAIL</review>`.

package/lib/prompt.md

@@ -0,0 +1,48 @@
+# Ralph v3.1 - Autonomous Agent Instructions
+
+You are "Ralph", an autonomous agent working in a split-state environment. Your goal is to complete tasks defined in `prd.md` while maintaining state in `prd.state.json`.
+
+## Context Files
+1.  **`prd.md`**: The Human Checklist. Read-Only for tasks.
+2.  **`prd.state.json`**: Your State. Write-Only for tracking status.
+3.  **`repo-map.md`**: Architectural Map.
+4.  **`progress.tail.log`**: Recent history (last ~200 lines).
+
+## Core Mandates
+
+### 1. Phase Awareness
+*   **PLAN MODE** (Triggered when `repo-map.md` is empty):
+    *   **Goal**: Explore structure (`ls -R`), read key files, and populate `repo-map.md`.
+    *   **Prohibited**: Do NOT write code or fix bugs yet. Just map.
+*   **BUILD MODE** (Triggered when map exists):
+    *   **Goal**: Pick the first unchecked item in `prd.md` and implement it.
+    *   **Guidance**: Prefer local tools first (`read`, `grep`, `glob`). Background agents are allowed **sparingly** when local tools are insufficient, and only one at a time.
+
+### 2. The PRD Contract
+*   **Read**: Look at `prd.md`. Find the first task usually marked `- [ ]`.
+*   **Check State**: Look at `prd.state.json`.
+    *   If a task is marked `verified: true`, it is DONE.
+    *   If `attempts > 3`, consider skipping or asking for help.
+*   **Update State**:
+    *   When you start a task, update `prd.state.json`.
+    *   When you finish, **YOU MUST VERIFY** (run tests/build).
+    *   ONLY if verification passes:
+        1.  Mark the checkbox in `prd.md` (change `[ ]` to `[x]`).
+        2.  Update `prd.state.json` to `verified: true`.
+
+### 3. Surgical Execution
+*   **Do not read the whole internet.** Read only what is needed.
+*   **Do not pollute logs.** Append ONE concise line to `progress.log` via the `write` tool (using `>>` or reading first then writing). Do not overwrite history.
+*   **Background agents (soft)**: If local tools can't find what you need, you may use **one** `background_task` at a time. Prefer `explore` for codebase search and `librarian` for external docs. Avoid webfetch/websearch unless explicitly required by the task.
+
+### 4. Non-Interactive Execution (CRITICAL)
+*   **Avoid Wizards**: NEVER run commands that might pause for user input (e.g., `npm init`, `next lint`, `eslint --init`) without ensuring a configuration file exists first.
+*   **Use Flags**: ALWAYS use non-interactive flags:
+    *   `npm init -y`
+    *   `apt-get install -y`
+    *   `next lint --no-cache` (ONLY if .eslintrc exists!)
+*   **Config First**: If a tool (like ESLint) needs a config, use `write` to create it (e.g., `.eslintrc.json`) BEFORE running the tool.
+
+### 5. Completion
+*   If ALL tasks in `prd.md` are checked `[x]`:
+    *   Output exactly: `<promise>COMPLETE</promise>`

package/lib/ralph.sh

@@ -0,0 +1,354 @@
+#!/bin/bash
+set -e
+
+
+# --- Hardened Environment (Anti-Interactive) ---
+export CI=1
+export GIT_TERMINAL_PROMPT=0
+export npm_config_yes=true
+export npm_config_audit=false
+export npm_config_fund=false
+export FORCE_COLOR=0
+export TERM=dumb
+
+# --- Configuration ---
+ITERATIONS=5
+WATCH_MODE="false"
+
+# Watchdog Tunables
+RALPH_MAX_TURN_SECONDS=${RALPH_MAX_TURN_SECONDS:-900}     # 15 min hard cap
+RALPH_NO_OUTPUT_SECONDS=${RALPH_NO_OUTPUT_SECONDS:-180}   # 3m without output => stuck
+
+# Model Priority: Build Phase (Implementation)
+# (Defaults - can be overridden by config)
+BUILD_MODELS_PREF=(
+    "github-copilot/gpt-5.2-codex"
+    "github-copilot/claude-sonnet-4.5"
+    "github-copilot/gemini-3-pro-preview"
+    "github-copilot-enterprise/gpt-5.2-codex"
+    "github-copilot-enterprise/claude-sonnet-4.5"
+    "github-copilot-enterprise/gemini-3-pro-preview"
+    "openai/gpt-5.2-codex"
+    "openai/gpt-5.1-codex-max"
+    "google/gemini-3-pro-preview"
+    "opencode/grok-code"
+)
+
+# Model Priority: Plan Phase (Reasoning/Architecture)
+PLAN_MODELS_PREF=(
+    "github-copilot/claude-opus-4.5"
+    "github-copilot/gemini-3-pro-preview"
+    "github-copilot-enterprise/claude-opus-4.5"
+    "github-copilot-enterprise/gemini-3-pro-preview"
+    "openai/gpt-5.2"
+    "google/antigravity-claude-opus-4-5-thinking"
+    "google/gemini-3-pro-preview"
+    "opencode/glm-4.7-free"
+)
+
+# --- Setup Directories ---
+# Resolve the directory where this script lives (lib/)
+SOURCE=${BASH_SOURCE[0]}
+while [ -L "$SOURCE" ]; do
+  DIR=$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )
+  SOURCE=$(readlink "$SOURCE")
+  [[ $SOURCE != /* ]] && SOURCE=$DIR/$SOURCE
+done
+ENGINE_DIR=$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )
+
+# PROJECT_DIR is where the user is running the command from
+PROJECT_DIR="$(pwd)"
+RUNS_DIR="$PROJECT_DIR/.ralph/runs"
+
+mkdir -p "$RUNS_DIR"
+
+# Cleanup trap
+trap "pkill -P $$; exit" SIGINT SIGTERM
+
+# --- Parse Args ---
+MODE="default"
+PROJECT_IDEA=""
+
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        new)
+            MODE="new"
+            PROJECT_IDEA="$2"
+            shift 2
+            ;;
+        --watch) WATCH_MODE="true"; shift ;;
+        *) ITERATIONS="$1"; shift ;;
+    esac
+done
+
+echo "🐾 Vibepup v1.0 (CLI Mode)"
+echo "   Engine:  $ENGINE_DIR"
+echo "   Context: $PROJECT_DIR"
+
+# --- Smart Model Discovery ---
+get_available_models() {
+    local PREF_MODELS=("$@")
+    local AVAILABLE_MODELS=()
+    
+    echo "🔍 Verifying available models..." >&2
+    
+    local ALL_MODELS=$(opencode models --refresh | grep -E "^[a-z0-9-]+\/[a-z0-9.-]+" || true)
+    
+    for PREF in "${PREF_MODELS[@]}"; do
+        if echo "$ALL_MODELS" | grep -q "^$PREF$"; then
+            AVAILABLE_MODELS+=("$PREF")
+        fi
+    done
+    
+    if [ ${#AVAILABLE_MODELS[@]} -eq 0 ]; then
+        echo "⚠️  No preferred models found. Falling back to generic discovery." >&2
+        AVAILABLE_MODELS+=($(echo "$ALL_MODELS" | grep "gpt-4o" | head -n 1))
+        AVAILABLE_MODELS+=($(echo "$ALL_MODELS" | grep "claude-sonnet" | head -n 1))
+    fi
+    
+    echo "${AVAILABLE_MODELS[@]}"
+}
+
+echo "   Configuring Build Models..."
+read -r -a BUILD_MODELS <<< "$(get_available_models "${BUILD_MODELS_PREF[@]}")"
+echo "   Build Chain: ${BUILD_MODELS[*]}"
+
+echo "   Configuring Plan Models..."
+read -r -a PLAN_MODELS <<< "$(get_available_models "${PLAN_MODELS_PREF[@]}")"
+echo "   Plan Chain:  ${PLAN_MODELS[*]}"
+
+
+# --- Phase 0: The Architect (Genesis) ---
+if [ "$MODE" == "new" ]; then
+    echo ""
+    echo "🏗️  Phase 0: The Architect"
+    echo "   Idea: $PROJECT_IDEA"
+    
+    ARCHITECT_MODEL="${PLAN_MODELS[0]}"
+    echo "   Using: $ARCHITECT_MODEL"
+    
+    # NOTE: We assume agents/architect.md is in lib/agents/
+    opencode run "PROJECT IDEA: $PROJECT_IDEA" \
+        --file "$ENGINE_DIR/agents/architect.md" \
+        --agent general \
+        --model "$ARCHITECT_MODEL"
+        
+    echo "✅ Architect initialization complete."
+fi
+
+
+# --- Initialization & Migration ---
+if [ ! -f "$PROJECT_DIR/prd.md" ]; then
+    if [ -f "$PROJECT_DIR/prd.json" ]; then
+        echo "🔄 Migrating legacy prd.json to prd.md..."
+        jq -r '.[] | "- [ ] " + .description' "$PROJECT_DIR/prd.json" > "$PROJECT_DIR/prd.md"
+        mv "$PROJECT_DIR/prd.json" "$PROJECT_DIR/prd.json.bak"
+    else
+        echo "⚠️  No prd.md found. Initializing..."
+        cat > "$PROJECT_DIR/prd.md" <<INNEREOF
+# Product Requirements Document (PRD)
+
+- [ ] Initialize repo-map.md with project architecture
+- [ ] Setup initial project structure
+INNEREOF
+    fi
+fi
+
+if [ ! -f "$PROJECT_DIR/repo-map.md" ]; then
+    touch "$PROJECT_DIR/repo-map.md"
+fi
+
+if [ ! -f "$PROJECT_DIR/prd.state.json" ]; then
+    echo "{}" > "$PROJECT_DIR/prd.state.json"
+fi
+
+touch "$PROJECT_DIR/progress.log"
+
+# --- Helper Functions ---
+
+detect_phase() {
+    if [ ! -s "$PROJECT_DIR/repo-map.md" ]; then
+        echo "PLAN"
+        return
+    fi
+    echo "BUILD"
+}
+
+get_current_prd_hash() {
+    md5sum "$PROJECT_DIR/prd.md" | awk '{print $1}'
+}
+
+prepare_iteration_context() {
+    local ITER_ID="$1"
+    local ITER_DIR="$RUNS_DIR/$ITER_ID"
+    mkdir -p "$ITER_DIR"
+    
+    tail -n 200 "$PROJECT_DIR/progress.log" > "$ITER_DIR/progress.tail.log"
+    
+    rm -f "$RUNS_DIR/latest"
+    ln -s "$ITER_DIR" "$RUNS_DIR/latest"
+    
+    echo "$ITER_DIR"
+}
+
+run_with_watchdog () {
+  local log="$1"; shift
+  : > "$log"
+
+  # run in background and capture output
+  ( "$@" 2>&1 | tee -a "$log" ) &
+  local pid=$!
+  local start=$(date +%s)
+  local last=$start
+  local last_size=0
+
+  while kill -0 "$pid" 2>/dev/null; do
+    sleep 5
+    local now=$(date +%s)
+    local size=$(wc -c < "$log" 2>/dev/null || echo 0)
+
+    if (( size != last_size )); then
+      last="$now"
+      last_size="$size"
+    fi
+
+    if (( now - start > RALPH_MAX_TURN_SECONDS )); then
+      echo "[RALPH] TIMEOUT: killing opencode turn" >> "$log"
+      kill -INT "$pid" 2>/dev/null || true
+      sleep 3
+      kill -TERM "$pid" 2>/dev/null || true
+      sleep 1
+      kill -KILL "$pid" 2>/dev/null || true
+      return 124
+    fi
+
+    if (( now - last > RALPH_NO_OUTPUT_SECONDS )); then
+      echo "[RALPH] NO OUTPUT: likely waiting for input / hung tool" >> "$log"
+      kill -INT "$pid" 2>/dev/null || true
+      sleep 3
+      kill -TERM "$pid" 2>/dev/null || true
+      sleep 1
+      kill -KILL "$pid" 2>/dev/null || true
+      return 125
+    fi
+  done
+
+  wait "$pid"
+}
+
+run_agent() {
+    local MODEL="$1"
+    local PHASE="$2"
+    local ITER_DIR="$3"
+    
+    local SYSTEM_PROMPT="$ENGINE_DIR/prompt.md"
+    local PROMPT_SUFFIX=""
+    local EXTRA_ARGS=()
+
+    if [ "$DESIGN_MODE" == "true" ]; then
+        echo "   🎨 Design Mode Active: Injecting frontend-design skill..."
+        EXTRA_ARGS+=( "--file" "$HOME/.config/opencode/skills/frontend-design.md" )
+        PROMPT_SUFFIX="MODE: DESIGN + BUILD. Apply the frontend-design skill guidelines to all work."
+    elif [ "$PHASE" == "PLAN" ]; then
+        PROMPT_SUFFIX="MODE: PLAN. Focus on exploring and mapping. Do NOT write implementation code yet."
+    else
+        PROMPT_SUFFIX="MODE: BUILD. Focus on completing tasks in prd.md."
+    fi
+
+    echo "   Thinking..."
+    
+    run_with_watchdog "$ITER_DIR/agent_response.txt" \
+        opencode run "Proceed with task. $PROMPT_SUFFIX" \
+        --file "$SYSTEM_PROMPT" \
+        --file "$PROJECT_DIR/prd.md" \
+        --file "$PROJECT_DIR/prd.state.json" \
+        --file "$PROJECT_DIR/repo-map.md" \
+        --file "$ITER_DIR/progress.tail.log" \
+        "${EXTRA_ARGS[@]}" \
+        --agent general \
+        --model "$MODEL"
+}
+
+# --- Main Loop ---
+LAST_HASH=$(get_current_prd_hash)
+i=1
+
+while true; do
+    # Watch Mode Check
+    # Only restart if hash changed EXTERNALLY (since last accepted state)
+    CURRENT_HASH=$(get_current_prd_hash)
+    if [[ "$CURRENT_HASH" != "$LAST_HASH" ]]; then
+        echo "👀 PRD Changed! Restarting loop..."
+        echo "--- PRD CHANGED: RESTARTING LOOP ---" >> "$PROJECT_DIR/progress.log"
+        LAST_HASH="$CURRENT_HASH"
+        
+        # Only reset counter if we are in infinite watch mode
+        if [[ "$WATCH_MODE" == "true" ]]; then
+            i=1
+        fi
+    fi
+
+    if [[ "$WATCH_MODE" != "true" ]] && ((i > ITERATIONS)); then
+        echo "⏸️  Max iterations reached."
+        break
+    fi
+
+    PHASE=$(detect_phase)
+    ITER_ID=$(printf "iter-%04d" $i)
+    ITER_DIR=$(prepare_iteration_context "$ITER_ID")
+    
+    echo ""
+    echo "🔁 Loop $i ($PHASE Phase)"
+    echo "   Logs: $ITER_DIR"
+
+    if [ "$PHASE" == "PLAN" ]; then
+        MODELS=("${PLAN_MODELS[@]}")
+    else
+        MODELS=("${BUILD_MODELS[@]}")
+    fi
+
+    SUCCESS=false
+    for MODEL in "${MODELS[@]}"; do
+        echo "   Using: $MODEL"
+        set +e
+        run_agent "$MODEL" "$PHASE" "$ITER_DIR"
+        EXIT_CODE=$?
+        set -e
+        
+        RESPONSE=$(cat "$ITER_DIR/agent_response.txt")
+        
+        if [ $EXIT_CODE -eq 0 ] && [ -n "$RESPONSE" ]; then
+            SUCCESS=true
+            echo "$RESPONSE"
+            
+            if echo "$RESPONSE" | grep -q "<promise>COMPLETE</promise>"; then
+                echo "✅ Agent signaled completion."
+                if [[ "$WATCH_MODE" != "true" ]]; then 
+                    exit 0
+                else
+                    echo "⏸️  Project Complete. Waiting for changes in prd.md..."
+                    while [[ "$(get_current_prd_hash)" == "$LAST_HASH" ]]; do
+                        sleep 2
+                    done
+                    echo "👀 Change detected! Resuming..."
+                    i=1
+                    continue
+                fi
+            fi
+            break
+        else
+            echo "   ⚠️  Model $MODEL failed (Exit: $EXIT_CODE). Falling back..."
+        fi
+    done
+
+    if [ "$SUCCESS" = false ]; then
+        echo "❌ All models failed this iteration."
+        sleep 2
+    fi
+
+    # Sync hash AFTER run so self-edits don't trigger restart
+    LAST_HASH=$(get_current_prd_hash)
+
+    ((i++))
+    sleep 1
+done

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "vibepup",
+  "version": "1.0.0",
+  "description": "A loyal, DX-first split-brain agent harness with cyberpunk vibes.",
+  "bin": "bin/ralph.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shantanusoam/ralph-project.git"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "automation",
+    "llm",
+    "dev-tool",
+    "dx",
+    "vibe-coding"
+  ],
+  "author": "Shantanu Soam",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shantanusoam/ralph-project/issues"
+  },
+  "homepage": "https://github.com/shantanusoam/ralph-project#readme"
+}