glori-builder 1.0.0

package/.claude/commands/auto-pilot.md

@@ -0,0 +1,228 @@
+---
+description: Work through all Linear issues in a project autonomously. Runs the full pipeline (architect → developers → QA → reviewer → merge) for each issue in dependency order, auto-merges PRs, and continues until the backlog is empty. Run after /plan-project to walk away and let Glori Builder finish the project.
+argument-hint: <LINEAR-PROJECT-ID>
+---
+
+# Auto-Pilot
+
+Works through every queued issue in a Linear project — one at a time, in dependency order — until the backlog is empty. Each issue runs the full Glori Builder pipeline and is auto-merged to main when QA and review pass.
+
+## Before Starting
+
+```bash
+# Verify LINEAR_API_KEY is set
+echo "${LINEAR_API_KEY:+set}"
+
+# Verify gh is authenticated
+gh auth status 2>&1 | head -1
+
+# Verify git is clean and on main
+git branch --show-current
+git status --porcelain
+```
+
+Stop if any check fails and tell the user what to fix.
+
+## Phase 1: Load the Backlog
+
+### Step 1a: Get project issues from Linear
+
+If `$ARGUMENTS` is provided, use it as the project ID. Otherwise, ask: "Which Linear project should I work? (provide the project ID)"
+
+Fetch all unstarted/backlog issues for this project, sorted by `sortOrder`:
+
+```bash
+curl -s -X POST https://api.linear.app/graphql \
+  -H "Authorization: $LINEAR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "{ issues(filter: { project: { id: { eq: \"PROJECT_ID\" } }, state: { type: { in: [\"unstarted\", \"backlog\"] } } }, orderBy: sortOrder) { nodes { id identifier title sortOrder state { name type } relations { nodes { type relatedIssue { id identifier state { type } } } } } } }"}'
+```
+
+### Step 1b: Build execution order
+
+From the results, build the dependency graph:
+- An issue is **ready** if all issues it is blocked by are in state `completed`
+- Sort ready issues by `sortOrder` (ascending)
+- Group into execution batches (same batch = no inter-dependency)
+
+Display the plan:
+
+```
+Auto-pilot plan: {N} issues
+
+Batch 1 (start immediately):
+  {identifier}: {title}
+  {identifier}: {title}
+
+Batch 2 (after Batch 1):
+  {identifier}: {title}
+
+...
+
+Issues will be worked sequentially within each batch.
+PRs will be auto-merged after QA and review pass.
+Failed issues (3 QA retries exhausted) will be skipped and logged.
+
+Proceed?
+```
+
+Wait for confirmation.
+
+### Step 1c: Initialize state file
+
+Create `.claude/autopilot-{YYYYMMDD-HHMM}.json`:
+
+```json
+{
+  "projectId": "PROJECT_ID",
+  "startedAt": "ISO_TIMESTAMP",
+  "issues": {}
+}
+```
+
+This file tracks progress and allows resuming if the session ends.
+
+---
+
+## Phase 2: Work Each Issue
+
+For each issue in execution order (batch by batch, sequential within batch):
+
+### Step 2a: Check if already done (resumable)
+
+```bash
+cat .claude/autopilot-*.json 2>/dev/null | python3 -c "
+import json, sys
+d = json.load(sys.stdin)
+print(d['issues'].get('ISSUE_ID', {}).get('status', 'pending'))
+"
+```
+
+If status is `complete` or `skipped`, skip to next issue.
+
+### Step 2b: Mark as in progress
+
+Update state file: `"ISSUE_ID": { "status": "in_progress", "retries": 0 }`
+
+Update Linear status to In Progress:
+
+```bash
+curl -s -X POST https://api.linear.app/graphql \
+  -H "Authorization: $LINEAR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "mutation { issueUpdate(id: \"ISSUE_UUID\", input: { stateId: \"IN_PROGRESS_STATE_ID\" }) { success } }"}'
+```
+
+### Step 2c: Create the feature branch
+
+```bash
+git checkout main && git pull origin main
+BRANCH="feature/$(echo '{identifier}-{title}' | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9-]/-/g' | cut -c1-60)"
+git checkout -b "$BRANCH"
+```
+
+### Step 2d: Run the pipeline
+
+Invoke each agent in sequence, passing the issue details:
+
+1. **Architect agent** — create implementation plan for this issue
+2. **Designer agent** (if architect flagged `designer_required: true`) — create design spec
+3. **Developer agent(s)** — spawn parallel workers per architect's file ownership map
+4. **Merge sub-branches** — merge each developer's sub-branch into the feature branch
+5. **QA agent** — run verification chain, report exit codes
+
+**If QA fails:**
+- Increment retry counter
+- If retries < 3: send exact failure output to developer agent(s), re-run developers and QA
+- If retries == 3: mark issue as `skipped`, add Linear comment explaining failures, continue to next issue
+
+6. **Reviewer agent** — semantic review of full diff
+   - If reviewer rejects: send feedback to developer, rerun developers → QA → reviewer (counts against retry limit)
+   - If reviewer approves: continue
+
+### Step 2e: Create and merge the PR
+
+**git-workflow agent** — commit, push, create PR.
+
+Wait for CI to pass:
+
+```bash
+gh pr checks {PR_NUMBER} --watch --timeout 600
+```
+
+If CI passes, auto-merge:
+
+```bash
+gh pr merge {PR_NUMBER} --squash
+```
+
+Pull new main:
+
+```bash
+git checkout main && git pull origin main
+```
+
+If CI fails after 2 minutes: treat as QA failure, increment retry counter.
+
+### Step 2f: Update status
+
+On **success**:
+- Update Linear issue to Done
+- Update state file: `"status": "complete", "pr": PR_NUMBER`
+- Add Linear comment: "Completed by Glori Builder auto-pilot."
+
+On **skip** (3 failures):
+- Update Linear issue to status `in_review` (human needs to look)
+- Update state file: `"status": "skipped", "reason": "3 QA/review cycles exhausted"`
+- Add Linear comment with the failure details
+
+### Step 2g: Context check
+
+After each issue, check context usage. If above 70%, run `/compact` before starting the next issue. Auto-pilot is fully resumable from the state file — a fresh session can continue with `/auto-pilot --resume`.
+
+---
+
+## Phase 3: Summary
+
+When all issues are processed (or none remain in a ready state):
+
+```
+Auto-pilot complete.
+
+✓ Completed: {N} issues
+  {identifier}: {title}
+  ...
+
+⚠ Skipped (needs human review): {N} issues
+  {identifier}: {title} — {failure summary}
+
+✗ Blocked (dependencies not met): {N} issues
+  {identifier}: {title} — waiting on {blocking-identifier}
+
+State log: .claude/autopilot-{timestamp}.json
+```
+
+For skipped issues: update Linear to `In Review` so they surface for manual attention.
+
+---
+
+## Resuming an Interrupted Run
+
+If auto-pilot stops mid-run (context overflow, session end, error):
+
+```
+/auto-pilot --resume
+```
+
+This reads the most recent `.claude/autopilot-*.json` state file, skips completed issues, and continues from where it left off.
+
+---
+
+## Notes
+
+- Issues are worked sequentially — parallel batches in v1 are sequential for reliability
+- Each issue gets a clean branch from the latest main after the previous merge
+- Auto-merge waits for CI to pass — branch protection is enforced
+- State file survives session restarts — auto-pilot is always resumable
+- Skipped issues are not deleted from Linear — they stay visible for human review
+- Run `/auto-pilot PROJECT-ID` at any time to work remaining backlog issues

package/.claude/commands/commit.md

@@ -0,0 +1,7 @@
+Create a new commit for all of our uncommitted changes
+run git status && git diff HEAD && git status --porcelain to see what files are uncommitted
+add the untracked and changed files
+
+Add an atomic commit message with an appropriate message
+
+add a tag such as "feat", "fix", "docs", etc. that reflects our work

package/.claude/commands/create-rules.md

@@ -0,0 +1,356 @@
+---
+description: Generate the project .claude/CLAUDE.md with stack, verification commands, and conventions. Choose from predefined templates (Next.js, Python, Rust, Rails, iOS, Go, Node.js) and customize. QA and developer agents read this file.
+---
+
+# Create Project Rules
+
+Generates `.claude/CLAUDE.md` for this project. The QA agent reads the Verification section to know which commands to run. The developer agent reads Conventions for code quality rules.
+
+Run once per project, after `/project-setup`.
+
+---
+
+## Step 1: Choose Your Stack
+
+Present these options:
+
+```
+Which stack best describes this project?
+
+1. Next.js      — TypeScript, App Router, Vitest, Biome
+2. Python       — FastAPI / Django / Flask, pytest, ruff, mypy
+3. Rust         — Axum / Actix / bare, cargo test, clippy
+4. Ruby on Rails — Rails 7, RSpec, RuboCop
+5. iOS          — Swift, SwiftUI, XCTest, SwiftLint
+6. Go           — net/http / Gin / Echo, go test, golangci-lint
+7. Node.js      — TypeScript, Express / Fastify, Vitest, Biome
+8. Custom       — I'll ask you about your stack
+```
+
+Wait for the user's choice.
+
+---
+
+## Step 2: Auto-Detect Details
+
+Scan existing files to fill in specifics before asking anything:
+
+```bash
+# Node-based projects
+cat package.json 2>/dev/null
+
+# Python projects
+cat pyproject.toml 2>/dev/null
+cat requirements.txt 2>/dev/null
+
+# Rust
+cat Cargo.toml 2>/dev/null
+
+# Ruby
+cat Gemfile 2>/dev/null
+
+# Go
+cat go.mod 2>/dev/null
+
+# iOS
+ls *.xcodeproj *.xcworkspace 2>/dev/null | head -3
+```
+
+Report what was detected. Use this to fill in template variables (ORM, framework variant, project name, etc.).
+
+---
+
+## Step 3: Customize
+
+Ask: "Anything to adjust? (ORM, framework variant, test runner, specific conventions, additional tools)"
+
+If no adjustments needed, proceed. Apply any changes to the template.
+
+---
+
+## Step 4: Write `.claude/CLAUDE.md`
+
+Apply the matching template below. Replace all `{variables}` with detected or provided values.
+
+---
+
+### Template: Next.js
+
+```markdown
+# Project: {project-name}
+
+## Stack
+- Language: TypeScript (strict)
+- Framework: Next.js {version} (App Router, React 19, Turbopack)
+- UI: {ShadCN + Tailwind CSS / other}
+- ORM: {Drizzle / Prisma} + PostgreSQL
+- State: TanStack Query v5 + Zustand
+- Testing: Vitest + React Testing Library
+- Linting: Biome
+
+## Verification
+Run in this order — all must pass before any PR:
+1. `npx biome check --write .`
+2. `npm run type-check`
+3. `npm run test`
+4. `npm run build`
+
+## Conventions
+- No `any` types — use proper TypeScript throughout
+- No `@ts-ignore` — fix the root cause
+- `snake_case` for database columns, `camelCase` for TypeScript
+- Server components by default — `"use client"` only when required
+- API routes in `app/api/`, server actions in `app/actions/`
+- Components in `components/`, hooks in `hooks/`, utilities in `lib/`
+
+## Key Commands
+- Dev server: `npm run dev`
+- DB push: `npx drizzle-kit push` / `npx prisma db push`
+- DB studio: `npx drizzle-kit studio` / `npx prisma studio`
+- Install: `npm install`
+```
+
+---
+
+### Template: Python
+
+```markdown
+# Project: {project-name}
+
+## Stack
+- Language: Python {version}
+- Framework: {FastAPI / Django / Flask}
+- ORM: {SQLAlchemy / Django ORM / Tortoise / SQLModel}
+- Testing: pytest{+ pytest-asyncio if async}
+- Linting: ruff + mypy
+- Package manager: {uv / pip / poetry}
+
+## Verification
+Run in this order — all must pass before any PR:
+1. `ruff check --fix .`
+2. `mypy .`
+3. `pytest`
+
+## Conventions
+- Type hints on all functions and return values — no untyped code
+- Pydantic models for all request/response schemas
+- `snake_case` everywhere
+- Tests mirror the module structure in `tests/`
+- Raise specific exceptions, not bare `Exception`
+
+## Key Commands
+- Dev server: `{uvicorn main:app --reload / python manage.py runserver}`
+- Install: `{uv sync / pip install -r requirements.txt}`
+- DB migrate: `{alembic upgrade head / python manage.py migrate}`
+```
+
+---
+
+### Template: Rust
+
+```markdown
+# Project: {project-name}
+
+## Stack
+- Language: Rust ({edition} edition)
+- Framework: {Axum / Actix-web / bare}
+- Testing: cargo test
+- Linting: clippy + rustfmt
+- DB: {sqlx / Diesel / SeaORM / none}
+
+## Verification
+Run in this order — all must pass before any PR:
+1. `cargo fmt --check`
+2. `cargo clippy -- -D warnings`
+3. `cargo test`
+4. `cargo build --release`
+
+## Conventions
+- No `unwrap()` or `expect()` in production paths — use `?` or handle errors explicitly
+- All public items documented with `///`
+- `snake_case` for functions/variables, `PascalCase` for types/traits/enums
+- Prefer `impl Trait` in function signatures over generics where possible
+- Error types implement `std::error::Error`
+
+## Key Commands
+- Run: `cargo run`
+- Check (fast): `cargo check`
+- Watch: `cargo watch -x run`
+```
+
+---
+
+### Template: Ruby on Rails
+
+```markdown
+# Project: {project-name}
+
+## Stack
+- Language: Ruby {version}
+- Framework: Rails {version}
+- Testing: RSpec + FactoryBot + Capybara
+- Linting: RuboCop + StandardRB
+- DB: PostgreSQL + Active Record
+
+## Verification
+Run in this order — all must pass before any PR:
+1. `bundle exec rubocop --autocorrect`
+2. `bundle exec rspec`
+
+## Conventions
+- Follow Rails conventions — convention over configuration
+- Thin controllers, fat models (service objects for complex logic)
+- `snake_case` for Ruby, Rails naming for files and classes
+- Use concerns for shared behaviour across models/controllers
+- Prefer scopes over class methods for queries
+
+## Key Commands
+- Dev: `bin/rails server`
+- Console: `bin/rails console`
+- Migrate: `bin/rails db:migrate`
+- Routes: `bin/rails routes`
+- Generate: `bin/rails generate ...`
+```
+
+---
+
+### Template: iOS
+
+```markdown
+# Project: {project-name}
+
+## Stack
+- Language: Swift {version}+
+- UI: SwiftUI
+- Architecture: MVVM
+- Testing: XCTest + Swift Testing
+- Linting: SwiftLint
+- Package manager: Swift Package Manager
+
+## Verification
+Run in this order — all must pass before any PR:
+1. `swiftlint lint --strict`
+2. `xcodebuild test -scheme {scheme-name} -destination 'platform=iOS Simulator,name=iPhone 16'`
+
+## Conventions
+- `PascalCase` for types, `camelCase` for variables and functions
+- `@State` and `@StateObject` only in Views — all business logic in ViewModels
+- `async`/`await` for all async operations — no completion handlers in new code
+- No force unwrap (`!`) in production code — use `guard let` or `if let`
+- Separate concerns: Views (UI only), ViewModels (logic), Services (data/network)
+
+## Key Commands
+- Build: `xcodebuild build -scheme {scheme-name}`
+- Open project: `open {project-name}.xcodeproj`
+- SPM resolve: `swift package resolve`
+```
+
+---
+
+### Template: Go
+
+```markdown
+# Project: {project-name}
+
+## Stack
+- Language: Go {version}
+- Framework: {net/http / Gin / Echo / Chi}
+- Testing: go test
+- Linting: golangci-lint
+- DB: {pgx / GORM / sqlx / none}
+
+## Verification
+Run in this order — all must pass before any PR:
+1. `golangci-lint run`
+2. `go vet ./...`
+3. `go test ./...`
+4. `go build ./...`
+
+## Conventions
+- Always check errors — never ignore with `_`
+- Package names: short, lowercase, no underscores
+- Interfaces defined at the consumer (not the producer)
+- `context.Context` as first argument for all I/O operations
+- Table-driven tests for pure functions
+
+## Key Commands
+- Run: `go run .`
+- Module tidy: `go mod tidy`
+- Format: `gofmt -w .`
+```
+
+---
+
+### Template: Node.js
+
+```markdown
+# Project: {project-name}
+
+## Stack
+- Language: TypeScript
+- Runtime: Node.js {version}
+- Framework: {Express / Fastify / Hono / Koa}
+- Testing: Vitest
+- Linting: Biome
+- DB: {Drizzle / Prisma / none}
+
+## Verification
+Run in this order — all must pass before any PR:
+1. `npx biome check --write .`
+2. `npm run type-check`
+3. `npm run test`
+4. `npm run build`
+
+## Conventions
+- No `any` types — use proper TypeScript
+- `async`/`await` — no raw callbacks
+- `snake_case` for database columns, `camelCase` for TypeScript
+- Centralised error handling middleware
+- Route handlers thin — business logic in service layer
+
+## Key Commands
+- Dev: `npm run dev`
+- Build: `npm run build`
+- Install: `npm install`
+```
+
+---
+
+### Template: Custom
+
+Ask the user these questions one at a time:
+
+1. "What language and version?"
+2. "What framework or runtime (if any)?"
+3. "What test runner?"
+4. "What linter / formatter?"
+5. "What are the exact verification commands to run before every PR?"
+6. "Any key naming or structural conventions to enforce?"
+
+Generate a CLAUDE.md in the same structure as the templates above.
+
+---
+
+## Step 5: Confirm
+
+Show the generated content and ask: "Does this look right? Anything to adjust?"
+
+Apply any corrections, then write the file.
+
+```bash
+mkdir -p .claude
+git add .claude/CLAUDE.md
+git commit -m "chore: add project rules for {stack}"
+```
+
+Report: "Project rules created. QA and developer agents will now read `.claude/CLAUDE.md` for stack conventions and verification commands."
+
+---
+
+## Notes
+
+- The Verification section drives the QA agent — get these commands right
+- The Conventions section drives the developer agent — be specific about type safety rules
+- Run `/create-rules` again any time the stack changes significantly
+- Partners on the same project get these rules automatically via git clone
+- To disable the Glori Builder welcome message for this project, add `quetrex_welcome: false` anywhere in this file