golem-cc 2.1.2 → 3.0.0

package/commands/golem/build.md

@@ -1,235 +0,0 @@
----
-name: golem:build
-description: Run autonomous build loop with observability
-allowed-tools: [Read, Write, Edit, Glob, Grep, Bash, Task]
----
-
-<objective>
-Act as a build lead that orchestrates sequential builder teammates. Each task gets its own builder with fresh context. You coordinate the work, track progress, and handle issues. The user can observe progress and intervene when needed.
-</objective>
-
-<execution_context>
-@~/.golem/prompts/PROMPT_build.md
-@~/.golem/agents/code-simplifier.md
-</execution_context>
-
-<context>
-Current ticket:
-```bash
-TICKET_ID=$(basename "$(pwd)" | grep -oE '(INC|SR)-[0-9]+' || echo "")
-if [ -n "$TICKET_ID" ]; then
-  cat .golem/tickets/$TICKET_ID.yaml 2>/dev/null
-fi
-echo "TICKET_ID=$TICKET_ID"
-```
-
-Load specs:
-```bash
-for f in .golem/specs/*.md; do echo "=== $f ==="; cat "$f"; echo; done 2>/dev/null
-```
-
-Load operational guide:
-```bash
-cat .golem/AGENTS.md 2>/dev/null || echo "No AGENTS.md - run /golem:spec first"
-```
-
-Load implementation plan:
-```bash
-cat .golem/IMPLEMENTATION_PLAN.md 2>/dev/null || echo "No plan - run /golem:plan first"
-```
-
-Check remaining tasks:
-```bash
-echo "Remaining tasks:"
-grep -c '^\- \[ \]' .golem/IMPLEMENTATION_PLAN.md 2>/dev/null || echo "0"
-echo ""
-echo "Completed tasks:"
-grep -c '^\- \[x\]' .golem/IMPLEMENTATION_PLAN.md 2>/dev/null || echo "0"
-```
-</context>
-
-<process>
-
-## Pre-flight Checks
-
-1. Verify .golem/IMPLEMENTATION_PLAN.md exists
-2. Verify .golem/specs/ directory has files
-3. Verify .golem/AGENTS.md has test commands
-4. Check for remaining tasks
-
-If missing prerequisites, instruct user to run appropriate command first.
-
-## Build Lead Role
-
-You are the **build lead**. Your job is to:
-- Track overall progress through the implementation plan
-- Spawn builder teammates for each task (one at a time, fresh context)
-- Monitor builder progress and relay status to the user
-- Handle failures and blocked tasks
-- Squash commits when a stage completes
-- Keep the user informed so they can intervene if needed
-
-You do NOT implement tasks yourself. You delegate to builders.
-
-## The Build Loop
-
-For each task in the current stage:
-
-### 1. Identify Next Task
-
-Read .golem/IMPLEMENTATION_PLAN.md and find the first incomplete task (`- [ ]`).
-
-Announce to the user:
-```
-=== Task {N.M}: {task title} ===
-Files: {expected files}
-Spawning builder...
-```
-
-### 2. Spawn Builder Teammate
-
-Create a builder teammate for this specific task:
-
-```
-Spawn a builder teammate with this prompt:
-
-"You are a builder. Complete this ONE task, then shut down.
-
-TASK: {task title}
-FILES: {expected files}
-NOTES: {implementation hints from plan}
-TESTS: {what tests verify this}
-
-WORKFLOW:
-1. Write tests first (red phase)
-2. Implement minimum code to pass tests (green phase)
-3. Run validation gates from .golem/AGENTS.md
-4. If gates fail: fix and retry (up to 3 attempts)
-5. Simplify code (remove comments, flatten logic, improve names)
-6. Re-run validation after simplification
-7. Report back: SUCCESS or BLOCKED with reason
-
-DO NOT commit. The lead handles commits.
-DO NOT modify the implementation plan. The lead handles that.
-
-If you get stuck (DB not running, missing dependency, unclear requirement),
-report BLOCKED immediately with a clear explanation. Do not retry forever."
-
-Require plan approval before implementation.
-```
-
-### 3. Monitor Builder
-
-Watch the builder's progress. The user can see this too.
-
-**If builder reports SUCCESS:**
-- Mark task complete in .golem/IMPLEMENTATION_PLAN.md
-- Create atomic commit:
-  ```bash
-  git add -A
-  git commit -m "wip: {brief task description}"
-  ```
-- Announce: `✓ Task {N.M} complete`
-- Shut down the builder
-- Continue to next task
-
-**If builder reports BLOCKED:**
-- Announce to user:
-  ```
-  ⚠ Task {N.M} BLOCKED
-  Reason: {builder's explanation}
-
-  Options:
-  1. I can skip this task and continue
-  2. You can provide guidance and I'll retry
-  3. You can fix the issue and tell me to retry
-  ```
-- Wait for user input before proceeding
-- Do NOT auto-retry blocked tasks
-
-**If builder is struggling (3+ failed attempts):**
-- Message the builder: "What's blocking you?"
-- Relay the answer to the user
-- Ask user how to proceed
-
-### 4. Stage Completion
-
-When all tasks in a stage are marked `[x]`:
-
-1. Announce: `=== Stage {N} Complete ===`
-
-2. Squash all wip commits:
-   ```bash
-   golem-api git:squash "{TICKET_ID}" -m "{stage commit message from plan}"
-   ```
-
-3. Update ticket status:
-   ```bash
-   golem-api ticket:status "{TICKET_ID}" in-progress --note "Stage {N} complete: {stage name}"
-   ```
-
-4. If more stages remain: announce and continue
-5. If all stages complete: proceed to completion
-
-### 5. Overall Completion
-
-When all stages are complete:
-```
-=== BUILD COMPLETE ===
-
-All {N} stages complete.
-Ticket: {TICKET_ID}
-
-Next steps:
-1. Run /golem:review for code review
-2. Run golem pr to create pull request
-```
-
-Update ticket status to "review".
-
-</process>
-
-<user_controls>
-
-The user can intervene at any time:
-
-- **"skip"** - Skip the current blocked task, continue to next
-- **"retry"** - Tell the current builder to try again
-- **"stop"** - Stop the build loop, keep progress
-- **"status"** - Show current progress summary
-- **Message the builder directly** - Use Shift+Up/Down to select and message
-
-As lead, relay these commands appropriately and keep the user informed.
-
-</user_controls>
-
-<success_criteria>
-For each task:
-- [ ] Builder spawned with fresh context
-- [ ] Tests written first
-- [ ] Implementation complete
-- [ ] All gates passing
-- [ ] Code simplified
-- [ ] Atomic commit created
-- [ ] Builder shut down
-
-For each stage:
-- [ ] All tasks complete
-- [ ] Commits squashed
-- [ ] Ticket status updated
-
-Overall:
-- [ ] User can observe progress
-- [ ] User can intervene when needed
-- [ ] Blocked tasks surfaced immediately
-</success_criteria>
-
-<important>
-- You are the LEAD, not the implementer - delegate to builders
-- Each builder gets ONE task, then shuts down (fresh context)
-- Surface blockers immediately - don't let builders spin
-- Keep the user informed at every step
-- The user can always intervene - that's the point
-- Builders should NOT commit or modify the plan
-- YOU handle commits, plan updates, and squashing
-</important>

package/commands/golem/config.md

@@ -1,55 +0,0 @@
----
-name: golem:config
-description: Show current configuration
-allowed-tools: [Read, Bash]
----
-
-<objective>
-Display current golem configuration - paths, environment files, and environment variables.
-</objective>
-
-<context>
-Paths:
-```bash
-echo "=== Paths ==="
-echo "GOLEM_HOME: ${GOLEM_HOME:-$HOME/.golem}"
-```
-
-Environment files:
-```bash
-echo ""
-echo "=== Environment Files ==="
-GOLEM_HOME="${GOLEM_HOME:-$HOME/.golem}"
-[[ -f "$GOLEM_HOME/.env" ]] && echo "✓ $GOLEM_HOME/.env" || echo "✗ $GOLEM_HOME/.env (not found)"
-[[ -f ".env" ]] && echo "✓ ./.env (local)" || echo "  ./.env (not found)"
-```
-
-Load and display variables:
-```bash
-echo ""
-echo "=== Freshservice ==="
-GOLEM_HOME="${GOLEM_HOME:-$HOME/.golem}"
-[[ -f "$GOLEM_HOME/.env" ]] && source "$GOLEM_HOME/.env"
-[[ -f ".env" ]] && source ".env"
-
-echo "FRESH_DOMAIN: ${FRESH_DOMAIN:-(not set)}"
-[[ -n "${FRESH_API_KEY:-}" ]] && echo "FRESH_API_KEY: (set)" || echo "FRESH_API_KEY: (not set) - REQUIRED"
-echo "FRESH_DEFAULT_GROUP_ID: ${FRESH_DEFAULT_GROUP_ID:-(not set)}"
-echo "FRESH_DEFAULT_CATEGORY: ${FRESH_DEFAULT_CATEGORY:-(not set)}"
-echo "FRESH_SOURCE_ID: ${FRESH_SOURCE_ID:-(not set)}"
-echo "FRESH_DEFAULT_EMAIL: ${FRESH_DEFAULT_EMAIL:-(not set)}"
-
-echo ""
-echo "=== Gitea ==="
-echo "GITEA_URL: ${GITEA_URL:-(not set)}"
-[[ -n "${GITEA_TOKEN:-}" ]] && echo "GITEA_TOKEN: (set)" || echo "GITEA_TOKEN: (not set) - REQUIRED"
-echo "GITEA_ORG: ${GITEA_ORG:-(not set)}"
-echo "GITEA_REPO: ${GITEA_REPO:-(not set)}"
-```
-</context>
-
-<process>
-1. Display all configuration context
-2. Highlight any missing required variables
-3. Note: Use `golem doctor` for connectivity tests
-</process>

package/commands/golem/doctor.md

@@ -1,137 +0,0 @@
----
-name: golem:doctor
-description: Diagnose setup issues
-allowed-tools: [Bash]
----
-
-<objective>
-Run diagnostic checks on golem installation and report any issues with suggested fixes.
-</objective>
-
-<context>
-Run doctor checks:
-```bash
-GOLEM_HOME="${GOLEM_HOME:-$HOME/.golem}"
-[[ -f "$GOLEM_HOME/.env" ]] && source "$GOLEM_HOME/.env"
-[[ -f ".env" ]] && source ".env"
-
-passed=0
-failed=0
-
-echo "=== Environment ==="
-if [[ -d "$GOLEM_HOME" ]]; then
-  echo "✓ $GOLEM_HOME directory exists"
-  passed=$((passed + 1))
-else
-  echo "✗ $GOLEM_HOME directory missing"
-  echo "  → Run: mkdir -p $GOLEM_HOME"
-  failed=$((failed + 1))
-fi
-
-if [[ -f "$GOLEM_HOME/.env" ]]; then
-  echo "✓ $GOLEM_HOME/.env file exists"
-  passed=$((passed + 1))
-else
-  echo "✗ $GOLEM_HOME/.env file missing"
-  echo "  → Create and configure $GOLEM_HOME/.env"
-  failed=$((failed + 1))
-fi
-
-missing_vars=""
-[[ -z "${FRESH_DOMAIN:-}" ]] && missing_vars="$missing_vars FRESH_DOMAIN"
-[[ -z "${FRESH_API_KEY:-}" ]] && missing_vars="$missing_vars FRESH_API_KEY"
-[[ -z "${GITEA_URL:-}" ]] && missing_vars="$missing_vars GITEA_URL"
-[[ -z "${GITEA_TOKEN:-}" ]] && missing_vars="$missing_vars GITEA_TOKEN"
-
-if [[ -z "$missing_vars" ]]; then
-  echo "✓ Required env vars set"
-  passed=$((passed + 1))
-else
-  echo "✗ Missing required env vars:$missing_vars"
-  echo "  → Edit $GOLEM_HOME/.env"
-  failed=$((failed + 1))
-fi
-
-echo ""
-echo "=== Dependencies ==="
-if command -v node &>/dev/null; then
-  echo "✓ node $(node --version)"
-  passed=$((passed + 1))
-else
-  echo "✗ node not found"
-  failed=$((failed + 1))
-fi
-
-if command -v pnpm &>/dev/null; then
-  echo "✓ pnpm $(pnpm --version)"
-  passed=$((passed + 1))
-else
-  echo "✗ pnpm not found"
-  failed=$((failed + 1))
-fi
-
-if command -v git &>/dev/null; then
-  echo "✓ git $(git --version | cut -d' ' -f3)"
-  passed=$((passed + 1))
-else
-  echo "✗ git not found"
-  failed=$((failed + 1))
-fi
-
-if command -v golem-api &>/dev/null; then
-  echo "✓ golem-api accessible"
-  passed=$((passed + 1))
-else
-  echo "✗ golem-api not found"
-  echo "  → Run: ./bin/install.sh in golem directory"
-  failed=$((failed + 1))
-fi
-
-echo ""
-echo "=== Installation ==="
-prompt_count=$(ls "$GOLEM_HOME/prompts/"*.md 2>/dev/null | wc -l | tr -d ' ')
-if [[ "$prompt_count" -gt 0 ]]; then
-  echo "✓ Prompts installed ($prompt_count files)"
-  passed=$((passed + 1))
-else
-  echo "✗ No prompts installed"
-  failed=$((failed + 1))
-fi
-
-agent_count=$(ls "$GOLEM_HOME/agents/"*.md 2>/dev/null | wc -l | tr -d ' ')
-if [[ "$agent_count" -gt 0 ]]; then
-  echo "✓ Agents installed ($agent_count files)"
-  passed=$((passed + 1))
-else
-  echo "✗ No agents installed"
-  failed=$((failed + 1))
-fi
-
-if [[ -d "$GOLEM_HOME/commands/golem" ]]; then
-  echo "✓ Commands installed"
-  passed=$((passed + 1))
-else
-  echo "✗ Commands not installed"
-  failed=$((failed + 1))
-fi
-
-if [[ -L "$HOME/.claude/commands/golem" ]] && [[ -d "$HOME/.claude/commands/golem" ]]; then
-  echo "✓ Claude integration linked"
-  passed=$((passed + 1))
-else
-  echo "✗ Claude integration not linked"
-  echo "  → Run: ln -sf $GOLEM_HOME/commands/golem ~/.claude/commands/golem"
-  failed=$((failed + 1))
-fi
-
-echo ""
-total=$((passed + failed))
-echo "=== Summary: $passed/$total checks passed ==="
-```
-</context>
-
-<process>
-1. Run all diagnostic checks
-2. Report any failures with suggested fixes
-3. For API connectivity tests, suggest running `golem doctor --check-apis`
-</process>

package/commands/golem/help.md

@@ -1,212 +0,0 @@
----
-name: golem:help
-description: Show all golem commands and usage
-allowed-tools: []
----
-
-<objective>
-Display help information for all golem commands.
-</objective>
-
-<response>
-# Golem - Personal Workflow Manager
-
-Golem integrates Freshworks tickets, Gitea issues, and local development into a unified workflow. Uses Claude Code agent teams for collaborative spec/plan/review phases.
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `/golem:spec` | Define specs with agent team (UX, Architect, Devil's Advocate) |
-| `/golem:plan` | Create implementation plan with agent team (per-layer + Devil's Advocate) |
-| `/golem:build` | Build lead + sequential builders (observable, interruptible) |
-| `/golem:security` | Run automated security scans (gitleaks, semgrep, pnpm audit, trivy) |
-| `/golem:review` | Security scans + code review agent team |
-| `/golem:simplify` | Run code simplifier on files |
-| `/golem:status` | Show current ticket/project status |
-| `/golem:help` | Show this help |
-
----
-
-## Default Workflow
-
-### 1. Setup (CLI)
-```bash
-golem import INC-1234        # Import ticket from Freshservice
-golem worktree               # Create isolated worktree for this ticket
-cd .golem/worktrees/INC-1234 # Enter the worktree
-claude                       # Start Claude Code
-```
-
-### 2. Spec Phase (`/golem:spec`)
-
-Agent team explores requirements from multiple angles:
-
-```
-You: /golem:spec
-
-[Agent team spawns]
-├── UX Advocate: "Who are the users? What's the simplest solution?"
-├── Architect: "What's the technical approach? What patterns fit?"
-└── Devil's Advocate: "Do we need this? What's the simpler alternative?"
-
-[Team debates and synthesizes]
-
-Output:
-├── .golem/specs/authentication.md
-├── .golem/specs/validation.md
-└── .golem/AGENTS.md (test/build/lint commands)
-```
-
-### 3. Plan Phase (`/golem:plan`)
-
-Agent team creates staged implementation plan:
-
-```
-You: /golem:plan
-
-[Agent team spawns based on project layers]
-├── Frontend Planner: "Component structure, state management"
-├── Backend Planner: "API design, business logic"
-├── Data Planner: "Schema, migrations, queries"
-└── Devil's Advocate: "Too complex? Better patterns?"
-
-[Team maps requirements to tasks]
-
-Output:
-└── .golem/IMPLEMENTATION_PLAN.md
-    ├── Stage 1: Setup (3 tasks) → "feat(auth): add login endpoint"
-    ├── Stage 2: Core Logic (5 tasks) → "feat(auth): implement validation"
-    └── Stage 3: Integration (2 tasks) → "feat(auth): wire up frontend"
-```
-
-### 4. Build Phase (`/golem:build`)
-
-Lead orchestrates builders, you observe and intervene:
-
-```
-You: /golem:build
-
-[Build lead starts]
-=== Task 1.1: Create auth service ===
-Spawning builder...
-
-[Builder works - you can watch]
-├── Writing tests (red phase)
-├── Implementing (green phase)
-├── Running validation gates
-├── Simplifying code
-└── Reporting: SUCCESS
-
-✓ Task 1.1 complete
-=== Task 1.2: Add password validation ===
-Spawning builder...
-
-[If something breaks]
-⚠ Task 1.3 BLOCKED
-Reason: Cannot connect to database
-
-Options:
-1. Skip and continue
-2. Provide guidance
-3. Fix and retry
-
-You: The DB is on port 5433, not 5432
-[Lead relays to builder, continues]
-
-[Stage complete]
-=== Stage 1 Complete ===
-Squashing commits...
-```
-
-**Build controls:**
-- `skip` - Skip blocked task
-- `retry` - Retry current task
-- `stop` - Pause build
-- `status` - Show progress
-- `Shift+Up/Down` - Message builder directly
-
-### 5. Review Phase (`/golem:review`)
-
-Security scans first, then agent team review:
-
-```
-You: /golem:review
-
-[Security gate - automated tools]
-=== SECRETS SCAN (gitleaks) ===
-✓ No secrets detected
-
-=== SAST SCAN (semgrep) ===
-✓ 0 findings
-
-=== DEPENDENCY SCAN (pnpm audit) ===
-✓ 0 high, 0 critical
-
-[Agent team spawns for code review]
-├── Security Patterns: Auth logic, input validation
-├── Performance: Query patterns, algorithms
-├── Correctness: Spec match, edge cases
-├── Tests: Coverage, quality
-└── Devil's Advocate: Overengineered? Maintainable?
-
-[Team reports findings]
-
-Output:
-└── .golem/REVIEW_REPORT.md
-    ├── Verdict: APPROVED (or BLOCKED)
-    ├── 0 critical, 1 major, 3 minor issues
-    └── Recommendations for future work
-```
-
-### 6. Ship (CLI)
-```bash
-golem pr                     # Create pull request
-# Review, merge, done
-```
-
----
-
-## Files Generated
-
-| File | Created By | Purpose |
-|------|------------|---------|
-| `.golem/specs/*.md` | /golem:spec | Requirements for each topic |
-| `.golem/AGENTS.md` | /golem:spec | Test/build/lint commands |
-| `.golem/IMPLEMENTATION_PLAN.md` | /golem:plan | Staged task list |
-| `.golem/SECURITY_REPORT.md` | /golem:security | Scan results |
-| `.golem/REVIEW_REPORT.md` | /golem:review | Code review findings |
-
----
-
-## Agent Teams
-
-All phases use a **Devil's Advocate** who:
-- Must articulate WHY something is problematic
-- Must propose a concrete alternative
-- Must back down when concern is addressed
-- Goal: better thinking, not blocking progress
-
----
-
-## Environment Setup
-
-```bash
-# ~/.golem/.env
-FRESH_DOMAIN=yourcompany.freshservice.com
-FRESH_API_KEY=your_api_key
-GITEA_URL=https://gitea.example.com
-GITEA_TOKEN=your_token
-GITEA_ORG=your-org
-GITEA_REPO=your-repo
-```
-
-```json
-// Claude Code settings.json - enable agent teams
-{
-  "env": {
-    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
-  }
-}
-```
-</response>