golem-cc 0.1.0

package/bin/install.cjs

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// Colors
+const cyan = '\x1b[36m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+const banner = `
+${cyan}   ██████╗  ██████╗ ██╗     ███████╗███╗   ███╗
+  ██╔════╝ ██╔═══██╗██║     ██╔════╝████╗ ████║
+  ██║  ███╗██║   ██║██║     █████╗  ██╔████╔██║
+  ██║   ██║██║   ██║██║     ██╔══╝  ██║╚██╔╝██║
+  ╚██████╔╝╚██████╔╝███████╗███████╗██║ ╚═╝ ██║
+   ╚═════╝  ╚═════╝ ╚══════╝╚══════╝╚═╝     ╚═╝${reset}
+
+  Golem ${dim}v${pkg.version}${reset}
+  Autonomous coding loop with Claude
+  Structured specs → Ralph loop → Code simplification
+`;
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+const hasHelp = args.includes('--help') || args.includes('-h');
+
+console.log(banner);
+
+// Show help if requested
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx golem-cc [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-g, --global${reset}    Install globally (to ~/.claude)
+    ${cyan}-l, --local${reset}     Install locally (to ./.claude in current directory)
+    ${cyan}-h, --help${reset}      Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Install to default ~/.claude directory${reset}
+    npx golem-cc --global
+
+    ${dim}# Install to current project only${reset}
+    npx golem-cc --local
+
+  ${yellow}After Installation:${reset}
+    golem              Launch Claude Code
+    golem --yolo       Launch with --dangerously-skip-permissions
+    golem --install    Install/update golem
+
+  ${yellow}Commands (in Claude):${reset}
+    /golem:spec        Build project specs through conversation
+    /golem:plan        Create implementation plan
+    /golem:build       Run autonomous build loop
+    /golem:simplify    Simplify code
+    /golem:status      Show project status
+    /golem:help        Show all commands
+`);
+  process.exit(0);
+}
+
+/**
+ * Install golem shell alias to user's shell config
+ */
+function installShellAlias() {
+  const homeDir = os.homedir();
+
+  const shellConfigs = [
+    { file: '.zshrc', shell: 'zsh' },
+    { file: '.bashrc', shell: 'bash' },
+    { file: '.bash_profile', shell: 'bash' },
+    { file: '.profile', shell: 'sh' }
+  ];
+
+  const golemFunction = `
+# Golem - Autonomous coding loop
+# Installed by: npx golem-cc
+golem() {
+  local GOLEM_SCRIPT="$HOME/.golem/bin/golem"
+  if [[ -f "$GOLEM_SCRIPT" ]]; then
+    "$GOLEM_SCRIPT" "$@"
+  elif [[ "$1" == "--install" ]]; then
+    shift
+    npx golem-cc "$@"
+  else
+    echo "Golem not installed. Run: npx golem-cc --global"
+  fi
+}
+`;
+
+  let configPath = null;
+  let configName = null;
+
+  for (const { file } of shellConfigs) {
+    const fullPath = path.join(homeDir, file);
+    if (fs.existsSync(fullPath)) {
+      configPath = fullPath;
+      configName = file;
+      break;
+    }
+  }
+
+  if (!configPath) {
+    const defaultShell = process.env.SHELL || '/bin/zsh';
+    if (defaultShell.includes('zsh')) {
+      configPath = path.join(homeDir, '.zshrc');
+      configName = '.zshrc';
+    } else {
+      configPath = path.join(homeDir, '.bashrc');
+      configName = '.bashrc';
+    }
+  }
+
+  try {
+    let content = '';
+    if (fs.existsSync(configPath)) {
+      content = fs.readFileSync(configPath, 'utf8');
+    }
+
+    // Remove old golem function/alias
+    if (content.includes('golem()') || content.includes('# Golem alias')) {
+      content = content.replace(/\n# Golem alias for Claude Code\ngolem\(\) \{[\s\S]*?\n\}\n/g, '');
+      content = content.replace(/\n# Golem alias.*\nalias golem=.*\n/g, '');
+    }
+
+    content = content.trimEnd() + '\n' + golemFunction;
+    fs.writeFileSync(configPath, content);
+
+    console.log(`  ${green}✓${reset} Installed golem alias to ~/${configName}`);
+    return configName;
+  } catch (e) {
+    console.log(`  ${yellow}⚠${reset} Could not install shell alias: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Recursively copy directory, replacing paths in .md files
+ */
+function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true });
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyWithPathReplacement(srcPath, destPath, pathPrefix);
+    } else if (entry.name.endsWith('.md')) {
+      let content = fs.readFileSync(srcPath, 'utf8');
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      fs.writeFileSync(destPath, content);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Verify installation
+ */
+function verifyInstalled(dirPath, description) {
+  if (!fs.existsSync(dirPath)) {
+    console.error(`  ${yellow}✗${reset} Failed to install ${description}`);
+    return false;
+  }
+  try {
+    const entries = fs.readdirSync(dirPath);
+    if (entries.length === 0) {
+      console.error(`  ${yellow}✗${reset} ${description} is empty`);
+      return false;
+    }
+  } catch (e) {
+    console.error(`  ${yellow}✗${reset} Failed: ${e.message}`);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Install to the specified directory
+ */
+function install(isGlobal) {
+  const src = path.join(__dirname, '..');
+  const claudeDir = isGlobal
+    ? path.join(os.homedir(), '.claude')
+    : path.join(process.cwd(), '.claude');
+
+  const golemHomeDir = path.join(os.homedir(), '.golem');
+
+  const locationLabel = isGlobal
+    ? '~/.claude'
+    : './.claude';
+
+  const pathPrefix = isGlobal ? '~/.claude/' : './.claude/';
+
+  console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
+
+  const failures = [];
+
+  // Create directories
+  fs.mkdirSync(claudeDir, { recursive: true });
+
+  // For global install, also install the golem CLI script
+  if (isGlobal) {
+    const binDir = path.join(golemHomeDir, 'bin');
+    fs.mkdirSync(binDir, { recursive: true });
+
+    const golemScriptSrc = path.join(src, 'bin', 'golem');
+    const golemScriptDest = path.join(binDir, 'golem');
+
+    if (fs.existsSync(golemScriptSrc)) {
+      fs.copyFileSync(golemScriptSrc, golemScriptDest);
+      fs.chmodSync(golemScriptDest, 0o755);
+      console.log(`  ${green}✓${reset} Installed golem CLI to ~/.golem/bin/`);
+
+      // Also copy golem directory for the CLI to reference
+      const golemDataSrc = path.join(src, 'golem');
+      const golemDataDest = path.join(golemHomeDir, 'golem');
+      copyWithPathReplacement(golemDataSrc, golemDataDest, pathPrefix);
+    }
+  }
+
+  // Copy commands/golem
+  const commandsDir = path.join(claudeDir, 'commands');
+  fs.mkdirSync(commandsDir, { recursive: true });
+  const golemCmdSrc = path.join(src, 'commands', 'golem');
+  const golemCmdDest = path.join(commandsDir, 'golem');
+  copyWithPathReplacement(golemCmdSrc, golemCmdDest, pathPrefix);
+  if (verifyInstalled(golemCmdDest, 'commands/golem')) {
+    console.log(`  ${green}✓${reset} Installed /golem:* commands`);
+  } else {
+    failures.push('commands/golem');
+  }
+
+  // Copy golem directory (prompts, agents)
+  const golemSrc = path.join(src, 'golem');
+  const golemDest = path.join(claudeDir, 'golem');
+  copyWithPathReplacement(golemSrc, golemDest, pathPrefix);
+  if (verifyInstalled(golemDest, 'golem')) {
+    console.log(`  ${green}✓${reset} Installed golem prompts and agents`);
+  } else {
+    failures.push('golem');
+  }
+
+  // Write VERSION file
+  const versionDest = path.join(claudeDir, 'golem', 'VERSION');
+  fs.writeFileSync(versionDest, pkg.version);
+  console.log(`  ${green}✓${reset} Wrote VERSION (${pkg.version})`);
+
+  // Install shell alias
+  installShellAlias();
+
+  if (failures.length > 0) {
+    console.error(`\n  ${yellow}Installation incomplete!${reset} Failed: ${failures.join(', ')}`);
+    process.exit(1);
+  }
+
+  console.log(`
+  ${green}Done!${reset}
+
+  ${yellow}Next steps:${reset}
+  1. Restart your shell (or run: source ~/.zshrc)
+  2. Run ${cyan}golem${reset} to launch Claude Code
+  3. Run ${cyan}/golem:help${reset} to see available commands
+
+  ${yellow}Workflow:${reset}
+  /golem:spec    → Define requirements through conversation
+  /golem:plan    → Generate implementation plan
+  /golem:build   → Run autonomous coding loop
+`);
+}
+
+/**
+ * Prompt for install location
+ */
+function promptLocation() {
+  if (!process.stdin.isTTY) {
+    console.log(`  ${yellow}Non-interactive terminal, defaulting to local install${reset}\n`);
+    install(false);
+    return;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  let answered = false;
+
+  rl.on('close', () => {
+    if (!answered) {
+      answered = true;
+      console.log(`\n  ${yellow}Defaulting to local install${reset}\n`);
+      install(false);
+    }
+  });
+
+  console.log(`  ${yellow}Where would you like to install?${reset}
+
+  ${cyan}1${reset}) Local  ${dim}(./.claude)${reset} - this project only (Recommended)
+  ${cyan}2${reset}) Global ${dim}(~/.claude)${reset} - available in all projects
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    answered = true;
+    rl.close();
+    const choice = answer.trim() || '1';
+    const isGlobal = choice === '2';
+    install(isGlobal);
+  });
+}
+
+// Main
+if (hasGlobal && hasLocal) {
+  console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
+  process.exit(1);
+} else if (hasGlobal) {
+  install(true);
+} else if (hasLocal) {
+  install(false);
+} else {
+  promptLocation();
+}

package/commands/golem/build.md

@@ -0,0 +1,145 @@
+---
+name: golem:build
+description: Run autonomous build loop - implement, test, simplify, commit
+allowed-tools: [Read, Write, Edit, Glob, Grep, Bash, Task]
+---
+
+<objective>
+Execute the autonomous build loop: select a task, implement it, validate with tests, simplify the code, update the plan, and commit. Repeat until all tasks are complete or user interrupts.
+</objective>
+
+<execution_context>
+@~/.claude/golem/prompts/PROMPT_build.md
+@~/.claude/golem/agents/code-simplifier.md
+</execution_context>
+
+<context>
+Load specs:
+```bash
+for f in specs/*.md; do echo "=== $f ==="; cat "$f"; echo; done 2>/dev/null
+```
+
+Load operational guide:
+```bash
+cat AGENTS.md 2>/dev/null || echo "No AGENTS.md - run /golem:spec first"
+```
+
+Load implementation plan:
+```bash
+cat IMPLEMENTATION_PLAN.md 2>/dev/null || echo "No plan - run /golem:plan first"
+```
+
+Check remaining tasks:
+```bash
+grep -c '^\- \[ \]' IMPLEMENTATION_PLAN.md 2>/dev/null || echo "0"
+```
+</context>
+
+<process>
+
+## Pre-flight Checks
+
+1. Verify IMPLEMENTATION_PLAN.md exists
+2. Verify specs/ directory has files
+3. Verify AGENTS.md has test commands
+4. Check for remaining tasks
+
+If missing prerequisites, instruct user to run appropriate command first.
+
+## Build Loop
+
+For each iteration:
+
+### 1. Orient
+- Read the current IMPLEMENTATION_PLAN.md
+- Review relevant specs for context
+
+### 2. Select Task
+- Pick the **first** incomplete task (marked `[ ]`)
+- Skip only if it has unmet dependencies
+- Never cherry-pick based on preference
+
+### 3. Investigate
+- Search relevant source code
+- Understand existing patterns
+- Identify files to modify
+
+### 4. Implement
+- Make changes required for this task ONLY
+- Follow existing code patterns and conventions
+- Write tests alongside implementation
+- Keep changes minimal and focused
+
+### 5. Validate (Backpressure)
+Run ALL gates from AGENTS.md. ALL must pass:
+
+```bash
+# Run test command
+{test_command from AGENTS.md}
+
+# Run typecheck if configured
+{typecheck_command from AGENTS.md}
+
+# Run lint if configured
+{lint_command from AGENTS.md}
+```
+
+If any gate fails:
+- Read the error carefully
+- Fix the issue
+- Re-run ALL gates
+- Repeat until all pass
+
+### 6. Simplify
+After tests pass, simplify modified files:
+
+Use the code-simplifier agent principles:
+- Remove unnecessary comments
+- Flatten nested conditionals
+- Improve variable/function names
+- Remove dead code
+- **Preserve ALL behavior**
+
+Then re-run tests to confirm no regressions.
+
+### 7. Update Plan
+Edit `IMPLEMENTATION_PLAN.md`:
+- Change `[ ]` to `[x]` for completed task
+- Update status counts
+- Add notes about discoveries
+- Add new tasks if implementation revealed missing work
+
+### 8. Commit
+Single commit with clear message:
+
+```bash
+git add -A
+git commit -m "{type}({scope}): {description}
+
+Co-Authored-By: Claude <noreply@anthropic.com>"
+```
+
+Types: feat, fix, test, refactor, docs, chore
+
+### 9. Check Completion
+- If remaining tasks > 0: continue to next iteration
+- If all tasks complete: announce completion
+- If stuck for 3+ attempts on same task: mark blocked and move on
+
+</process>
+
+<success_criteria>
+- [ ] Task selected from plan
+- [ ] Implementation complete
+- [ ] All tests passing
+- [ ] Code simplified
+- [ ] Plan updated
+- [ ] Changes committed
+</success_criteria>
+
+<important>
+- Complete ONE task per message, then check if user wants to continue
+- Fresh context helps - don't accumulate too much in one session
+- Trust the tests - if they pass, implementation is correct
+- If stuck, mark task blocked and move on
+</important>

package/commands/golem/help.md

@@ -0,0 +1,58 @@
+---
+name: golem:help
+description: Show all golem commands and usage
+allowed-tools: []
+---
+
+<objective>
+Display help information for all golem commands.
+</objective>
+
+<process>
+Print the following help text:
+
+```
+╔═══════════════════════════════════════════════════════════════════╗
+║                           GOLEM                                   ║
+║              Autonomous Coding Loop with Claude                   ║
+╚═══════════════════════════════════════════════════════════════════╝
+
+WORKFLOW COMMANDS
+
+  /golem:spec              Build project specs through guided conversation
+  /golem:plan              Create implementation plan from specs
+  /golem:build             Run autonomous build loop (implement, test, simplify)
+  /golem:status            Show current project status
+
+UTILITY COMMANDS
+
+  /golem:simplify [path]   Run code simplifier on files
+  /golem:help              Show this help
+
+WORKFLOW
+
+  1. Run /golem:spec to define requirements through conversation
+  2. Run /golem:plan to generate IMPLEMENTATION_PLAN.md
+  3. Run /golem:build to start the autonomous coding loop
+
+Each build iteration:
+  • Selects highest-priority task
+  • Implements the change
+  • Runs tests (backpressure)
+  • Simplifies code
+  • Commits and loops
+
+FILES
+
+  specs/                   Requirement files (one per topic)
+  AGENTS.md               Operational commands (test, build, lint)
+  IMPLEMENTATION_PLAN.md   Task list with priorities
+  .golem/                  Configuration and prompts
+
+CLI USAGE
+
+  golem                    Launch Claude Code
+  golem --yolo             Launch with --dangerously-skip-permissions
+  golem --install          Install/update golem in a project
+```
+</process>

package/commands/golem/plan.md

@@ -0,0 +1,125 @@
+---
+name: golem:plan
+description: Create implementation plan from specs
+allowed-tools: [Read, Write, Glob, Grep, Bash]
+---
+
+<objective>
+Analyze specs versus existing code and create/update IMPLEMENTATION_PLAN.md with prioritized tasks.
+</objective>
+
+<execution_context>
+@~/.claude/golem/prompts/PROMPT_plan.md
+</execution_context>
+
+<context>
+Load all specs:
+```bash
+for f in specs/*.md; do echo "=== $f ==="; cat "$f"; echo; done 2>/dev/null || echo "No specs found - run /golem:spec first"
+```
+
+Load operational guide:
+```bash
+cat AGENTS.md 2>/dev/null || echo "No AGENTS.md found"
+```
+
+Existing plan (if any):
+```bash
+cat IMPLEMENTATION_PLAN.md 2>/dev/null || echo "No existing plan"
+```
+</context>
+
+<process>
+
+## 1. Read All Specs
+
+Read each file in `specs/` completely. Extract:
+- Concrete requirements (must have, should have)
+- Acceptance criteria
+- Technical constraints
+- Dependencies between specs
+
+## 2. Analyze Existing Code
+
+Search the codebase to understand current state:
+- What's already implemented?
+- Current architecture and patterns
+- Reusable components
+- Technical debt or issues
+
+## 3. 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
+
+## 4. Generate Tasks
+
+Create atomic, testable tasks:
+- Each task should be completable in one focused session
+- Typically affects 1-3 files
+- Has clear verification criteria
+- Minimal dependencies on other tasks
+
+**Bad task**: "Implement authentication"
+**Good task**: "Implement user registration with email/password"
+
+## 5. Prioritize
+
+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
+
+## 6. Write Plan
+
+Create or update `IMPLEMENTATION_PLAN.md`:
+
+```markdown
+# Implementation Plan
+
+Generated: {ISO timestamp}
+Based on: specs/*.md
+
+## Status
+- Total tasks: N
+- Completed: 0
+- Remaining: N
+
+## 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}
+
+### [ ] 2. {Next task}
+Priority: High
+Files: {files}
+Notes: {notes}
+
+...
+```
+
+</process>
+
+<success_criteria>
+- [ ] All specs analyzed
+- [ ] Gap analysis completed
+- [ ] Tasks are atomic and testable
+- [ ] Dependencies mapped correctly
+- [ ] IMPLEMENTATION_PLAN.md written
+- [ ] No code changes made (planning only)
+</success_criteria>
+
+<important>
+- Do NOT implement anything in planning mode
+- Do NOT modify source code
+- ONLY create/update IMPLEMENTATION_PLAN.md
+- Be thorough - missing tasks cause problems later
+- Tasks should be achievable in one iteration
+</important>