golem-cc 0.1.15 → 0.1.16

package/bin/golem

@@ -275,47 +275,23 @@ run_plan_mode() {
     echo -e "${DIM}Analyzing specs and creating implementation plan.${NC}"
     echo ""
 
-    # Build prompt file (Ralph pattern: cat file | claude)
-    local prompt_file=$(mktemp)
-    trap "rm -f $prompt_file" EXIT
-
-    cat > "$prompt_file" << 'PROMPT_HEADER'
-You are in PLANNING MODE. Your job is to analyze the specs and create IMPLEMENTATION_PLAN.md.
-
-DO NOT implement anything. Only create the plan.
-
-PROMPT_HEADER
-
-    # Add planning prompt if available
+    # Find prompt file (uses @file references for context)
+    local prompt_file=""
     if [[ -f ".golem/prompts/PROMPT_plan.md" ]]; then
-        cat .golem/prompts/PROMPT_plan.md >> "$prompt_file"
-        echo "" >> "$prompt_file"
-    fi
-
-    echo "---" >> "$prompt_file"
-    echo "" >> "$prompt_file"
-    echo "# Specs" >> "$prompt_file"
-    echo "" >> "$prompt_file"
-
-    for spec in specs/*.md; do
-        if [[ -f "$spec" ]]; then
-            echo "## $(basename "$spec" .md)" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            cat "$spec" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-        fi
-    done
-
-    if [[ -f "AGENTS.md" ]]; then
-        echo "---" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "# Operational Guide" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        cat AGENTS.md >> "$prompt_file"
+        prompt_file=".golem/prompts/PROMPT_plan.md"
+    elif [[ -f "$GOLEM_DIR/golem/prompts/PROMPT_plan.md" ]]; then
+        prompt_file="$GOLEM_DIR/golem/prompts/PROMPT_plan.md"
+    else
+        echo -e "${RED}No PROMPT_plan.md found. Run golem --install first.${NC}"
+        exit 1
     fi
 
-    # Run planning (Ralph pattern: cat PROMPT | claude -p)
-    cat "$prompt_file" | claude -p --allowedTools "Read,Write,Edit,Glob,Grep"
+    # Ralph pattern: cat PROMPT | claude -p
+    cat "$prompt_file" | claude -p \
+        --dangerously-skip-permissions \
+        --output-format stream-json \
+        --model opus \
+        --verbose
 
     echo ""
     echo -e "${GREEN}Planning complete.${NC}"
@@ -341,18 +317,25 @@ run_build_loop() {
         exit 1
     fi
 
+    # Find prompt file
+    local build_prompt=""
+    if [[ -f ".golem/prompts/PROMPT_build.md" ]]; then
+        build_prompt=".golem/prompts/PROMPT_build.md"
+    elif [[ -f "$GOLEM_DIR/golem/prompts/PROMPT_build.md" ]]; then
+        build_prompt="$GOLEM_DIR/golem/prompts/PROMPT_build.md"
+    else
+        echo -e "${RED}No PROMPT_build.md found. Run golem --install first.${NC}"
+        exit 1
+    fi
+
     echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
     echo -e "${CYAN}  BUILD LOOP STARTED${NC}"
-    if [[ "$simplify" == "true" ]]; then
-        echo -e "${CYAN}  Mode: Implement → Simplify (2 steps per iteration)${NC}"
-    fi
     echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
 
     local iteration=0
     local start_time=$(date +%s)
-    local prompt_file=$(mktemp)
-    trap "rm -f $prompt_file" EXIT
 
+    # Ralph loop: while :; do cat PROMPT | claude -p; done
     while true; do
         iteration=$((iteration + 1))
 
@@ -374,132 +357,16 @@ run_build_loop() {
         echo -e "${BLUE}  ITERATION $iteration  │  $remaining tasks remaining${NC}"
         echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
 
-        # ═══════════════════════════════════════════════════════════
-        # STEP 1: IMPLEMENT
-        # ═══════════════════════════════════════════════════════════
-        echo ""
-        echo -e "${GREEN}▶ Step 1: Implement${NC}"
-
-        # Build prompt file (Ralph pattern)
-        cat > "$prompt_file" << 'IMPLEMENT_HEADER'
-You are in BUILD MODE. Complete ONE task from the plan.
-
-DO NOT commit - just implement, test, update the plan, and stage changes.
-The commit will happen after simplification.
-
-IMPLEMENT_HEADER
-
-        # Add build prompt if available
-        if [[ -f ".golem/prompts/PROMPT_build.md" ]]; then
-            cat .golem/prompts/PROMPT_build.md >> "$prompt_file"
-            echo "" >> "$prompt_file"
-        fi
-
-        echo "---" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "# Specs" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-
-        for spec in specs/*.md; do
-            if [[ -f "$spec" ]]; then
-                echo "## $(basename "$spec" .md)" >> "$prompt_file"
-                echo "" >> "$prompt_file"
-                cat "$spec" >> "$prompt_file"
-                echo "" >> "$prompt_file"
-            fi
-        done
-
-        if [[ -f "AGENTS.md" ]]; then
-            echo "---" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            echo "# Operational Guide" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            cat AGENTS.md >> "$prompt_file"
-            echo "" >> "$prompt_file"
-        fi
-
-        echo "---" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "# Implementation Plan" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        cat IMPLEMENTATION_PLAN.md >> "$prompt_file"
-
-        # Run implementation (Ralph pattern: cat PROMPT | claude -p)
-        cat "$prompt_file" | claude -p --dangerously-skip-permissions
+        # Ralph pattern: cat PROMPT | claude -p
+        cat "$build_prompt" | claude -p \
+            --dangerously-skip-permissions \
+            --output-format stream-json \
+            --model opus \
+            --verbose
 
         local exit_code=$?
         if [[ $exit_code -ne 0 ]]; then
-            echo -e "${RED}Implementation step exited with error code $exit_code${NC}"
-        fi
-
-        # ═══════════════════════════════════════════════════════════
-        # STEP 2: SIMPLIFY + COMMIT
-        # ═══════════════════════════════════════════════════════════
-        echo ""
-        echo -e "${GREEN}▶ Step 2: Simplify + Commit${NC}"
-
-        # Get staged files
-        local staged_files=$(git diff --cached --name-only 2>/dev/null | grep -E '\.(ts|tsx|js|jsx|py|go|rs|vue)$' | grep -v '\.test\.' | grep -v '\.spec\.' | head -10)
-
-        # Build simplify prompt file
-        cat > "$prompt_file" << 'SIMPLIFY_HEADER'
-You are in SIMPLIFY + COMMIT MODE.
-
-SIMPLIFY_HEADER
-
-        if [[ "$simplify" == "true" ]] && [[ -n "$staged_files" ]]; then
-            cat >> "$prompt_file" << 'SIMPLIFY_INSTRUCTIONS'
-1. Simplify the staged source files (not tests)
-2. Run tests to verify no regressions
-3. Stage any changes from simplification
-4. Create a single commit with a comprehensive message
-
-SIMPLIFY_INSTRUCTIONS
-
-            # Add code-simplifier agent if available
-            if [[ -f ".golem/agents/code-simplifier.md" ]]; then
-                cat .golem/agents/code-simplifier.md >> "$prompt_file"
-                echo "" >> "$prompt_file"
-            fi
-
-            echo "---" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            echo "# Staged source files to simplify" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            echo "$staged_files" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-        else
-            cat >> "$prompt_file" << 'NO_SIMPLIFY'
-No source files to simplify. Just create the commit.
-
-Use conventional commit format with a descriptive body.
-
-NO_SIMPLIFY
-        fi
-
-        # Get current task for commit context
-        local current_task=$(grep -A3 '^\- \[ \]' IMPLEMENTATION_PLAN.md 2>/dev/null | head -4)
-        echo "---" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "# Task that was just completed" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "$current_task" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-
-        if [[ -f "AGENTS.md" ]]; then
-            echo "---" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            echo "# Operational Guide (for running tests)" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            cat AGENTS.md >> "$prompt_file"
-        fi
-
-        # Run simplify + commit (Ralph pattern)
-        cat "$prompt_file" | claude -p --dangerously-skip-permissions
-
-        exit_code=$?
-        if [[ $exit_code -ne 0 ]]; then
-            echo -e "${RED}Simplify + commit step exited with error code $exit_code${NC}"
+            echo -e "${RED}Build step exited with error code $exit_code${NC}"
         fi
 
         # Brief pause between iterations

package/golem/prompts/PROMPT_build.md

@@ -1,60 +1,47 @@
-# Ralph Build Mode
-
-You are operating in **build mode** - your job is to implement one task from the plan and validate it works.
-
-**Note:** Do NOT commit. Code simplification and commit happen in a separate step.
-
-## Execution Flow
-
-1. **Orient** - Read the specs and implementation plan below
-2. **Select** - Pick the highest-priority incomplete task (marked `[ ]`)
-3. **Investigate** - Search relevant source code to understand context
-4. **Implement** - Make the changes required for this task
-5. **Validate** - Run all backpressure gates (tests, typecheck, lint)
-6. **Fix** - If validation fails, fix issues and re-validate
-7. **Update Plan** - Mark task complete, add any discoveries
-8. **Stage** - Run `git add` on changed files (but DO NOT commit)
-
-## Rules
-
-### Task Selection
-- Always pick the **first** incomplete task unless it has unmet dependencies
-- Never skip tasks or cherry-pick based on preference
-- If blocked, note the blocker and select the next available task
-
-### Implementation
-- Implement ONLY what the task requires - no scope creep
-- Follow existing code patterns and conventions
-- Write tests alongside implementation code
-- Keep changes minimal and focused
-
-### Validation (Backpressure)
-Run these commands in order. ALL must pass before proceeding:
-1. Tests: `{test_command}`
-2. Type check: `{typecheck_command}` (if configured)
-3. Lint: `{lint_command}` (if configured)
-4. Build: `{build_command}` (if configured)
-
-If any gate fails:
-- Read the error carefully
-- Fix the issue
-- Re-run ALL gates from the beginning
-- Repeat until all pass
-
-### Plan Updates
-Edit `IMPLEMENTATION_PLAN.md`:
-- Change `[ ]` to `[x]` for completed task
-- Add notes about discoveries or blockers encountered
-- Add new tasks if implementation revealed missing work
-
-### Staging (No Commit!)
-Run `git add` on the files you changed, but DO NOT commit.
-The commit will happen after the simplification step.
-
-## Important
-
-- Complete ONE task per iteration, then exit
-- Fresh context on next iteration will continue from updated plan
-- If stuck on a task for more than 3 attempts, mark it blocked and move on
-- Trust the tests - if they pass, the implementation is correct
-- DO NOT commit - simplification step will handle that
+# Build Mode
+
+You are in BUILD MODE. Implement ONE task from the plan, then exit.
+
+## Phase 0: Orient
+
+Study these files to understand context:
+- @specs/* - All specification files
+- @AGENTS.md - Operational commands (test/build/lint)
+- @IMPLEMENTATION_PLAN.md - Current task list
+
+## Phase 1: Select Task
+
+1. Read IMPLEMENTATION_PLAN.md
+2. Pick the first incomplete task (marked `- [ ]`)
+3. Do NOT assume something is not implemented - search first
+
+## Phase 2: Implement
+
+1. Search codebase to understand existing patterns
+2. Make the required changes
+3. Follow existing code patterns exactly
+4. Write tests alongside implementation
+
+## Phase 3: Validate (Backpressure)
+
+Run commands from AGENTS.md in order. ALL must pass:
+1. Tests
+2. Type check (if configured)
+3. Lint (if configured)
+
+If ANY fails: fix the issue, then re-run ALL validation from the beginning.
+
+## Phase 4: Complete
+
+1. Update IMPLEMENTATION_PLAN.md - mark task `- [x]`
+2. Update AGENTS.md learnings if you discovered something useful
+3. Commit changes with descriptive message
+4. Exit
+
+## Phase 999: Critical Rules
+
+- Complete ONE task only per iteration
+- Do NOT skip validation - all gates must pass
+- Do NOT assume code doesn't exist - always search first
+- Trust the tests - passing = correct
+- Exit after committing so next iteration gets fresh context

package/golem/prompts/PROMPT_plan.md

@@ -1,84 +1,54 @@
-# Ralph Planning Mode
-
-You are operating in **planning mode** - your job is to analyze specs versus existing code and create/update the implementation plan.
-
-## Execution Flow
-
-1. **Read Specs** - Understand all requirements from specs/*.md
-2. **Analyze Code** - Search the codebase to understand current state
-3. **Gap Analysis** - Identify what needs to be built vs. what exists
-4. **Prioritize** - Order tasks by dependencies and criticality
-5. **Generate Plan** - Create/update IMPLEMENTATION_PLAN.md
-
-## Rules
-
-### Spec Analysis
-- Read each spec file completely
-- Extract concrete requirements (must have, should have)
-- Note acceptance criteria and constraints
-- Identify dependencies between specs
-
-### Code Analysis
-- Search for existing implementations
-- Understand current architecture and patterns
-- Identify reusable components
-- Note technical debt or issues
-
-### Gap Analysis
-For each requirement, determine:
-- **Done**: Already implemented and tested
-- **Partial**: Partially implemented, needs completion
-- **Missing**: Not implemented at all
-- **Blocked**: Depends on something not yet built
-
-### Task Generation
-Each task should be:
-- **Atomic** - Completable in one focused session
-- **Testable** - Has clear verification criteria
-- **Scoped** - Affects 1-3 files typically
-- **Independent** - Minimal dependencies on other tasks
-
-Bad task: "Implement authentication"
-Good task: "Implement user registration with email/password"
-
-### Priority Rules
-Order tasks by:
-1. **Critical path** - What blocks other work?
-2. **Dependencies** - What must be built first?
-3. **Risk** - Tackle unknowns early
-4. **Value** - Higher value tasks before nice-to-haves
+# Planning Mode
 
-### Plan Format
+You are in PLANNING MODE. Analyze specs vs existing code and create IMPLEMENTATION_PLAN.md.
 
-Write `IMPLEMENTATION_PLAN.md` in this format:
+## Phase 0: Orient
 
-```markdown
-# Implementation Plan
+Study these files first:
+- @specs/* - All specification files
+- @AGENTS.md - Operational commands
+- @IMPLEMENTATION_PLAN.md - Current plan (if exists)
+
+## Phase 1: Gap Analysis
+
+1. Read ALL spec files thoroughly
+2. Search the codebase extensively - use parallel subagents
+3. Do NOT assume something is missing - verify by searching
+4. Compare specs vs existing code
+5. Identify what's implemented vs what's missing
+
+## Phase 2: Create Plan
 
-Generated: {timestamp}
-Based on: specs/*.md
+Write `IMPLEMENTATION_PLAN.md` with prioritized tasks:
 
-## Status
-- Total tasks: N
-- Completed: 0
-- Remaining: N
+```markdown
+# Implementation Plan
 
 ## Tasks
 
-### [ ] 1. {Task title}
-Priority: Critical|High|Medium|Low
-Files: {expected files to create/modify}
-Notes: {implementation hints, constraints}
-Depends on: {task numbers if any}
+- [ ] 1. {Task title}
+  Priority: Critical|High|Medium|Low
+  Files: {files to create/modify}
+  Why: {capture the reasoning}
 
-### [ ] 2. {Next task}
-...
+- [ ] 2. {Next task}
+  ...
 ```
 
-## Important
+Order tasks by:
+1. Dependencies first (what blocks other work)
+2. Critical path (what's essential for MVP)
+3. Value (highest impact)
+
+## Phase 3: Exit
+
+After writing the plan, exit immediately.
+
+## Phase 999: Critical Rules
 
-- Do NOT implement anything in planning mode
-- Do NOT modify source code
-- ONLY create/update IMPLEMENTATION_PLAN.md
+- Do NOT assume something is not implemented - search first
+- Each task must be atomic (completable in one iteration)
+- Do NOT modify any source code
+- Do NOT implement anything - only create the plan
 - Be thorough - missing tasks cause problems later
-- Be realistic - tasks should be achievable in one iteration
+- Capture "the why" for each task

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "golem-cc",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Autonomous coding loop with Claude - structured specs, ralph loop execution, code simplification",
   "bin": {
     "golem-cc": "./bin/install.cjs"