autoworkflow 1.2.0 → 2.0.1

package/.claude/commands/analyze.md

@@ -0,0 +1,77 @@
+# /analyze - Analyze Command
+
+Analyze the codebase for a given task or question.
+
+## Trigger
+- User invokes `/analyze [topic]`
+- Or: Start of any new task (automatic)
+
+## Workflow
+
+### Step 1: Load Context
+```
+1. Read: CLAUDE.md (entry point)
+2. Read: system/router.md (task classification)
+3. Read: instructions/AI_RULES.md (standards)
+4. Read: instructions/BLUEPRINT.md (requirements)
+```
+
+### Step 2: Classify Task
+Route through `system/router.md`:
+- Is this a feature, fix, refactor, query, etc.?
+- What workflow applies?
+- What gates are required?
+
+### Step 3: Analyze Codebase
+```
+1. Search for relevant files
+2. Read affected code
+3. Note existing patterns
+4. Identify dependencies
+5. Check BLUEPRINT for requirements
+```
+
+### Step 4: Report Findings
+
+**Output Format:**
+```
+## Analysis: [topic]
+
+### Task Classification
+**Type:** [feature/fix/refactor/query/etc.]
+**Workflow:** [phases that apply]
+**Gates:** [required gates]
+
+### Relevant Files
+- `path/to/file1.tsx` - [why relevant]
+- `path/to/file2.ts` - [why relevant]
+
+### Existing Patterns
+- [Pattern 1 observed]
+- [Pattern 2 observed]
+
+### Blueprint Requirements
+- [Relevant requirement 1]
+- [Relevant requirement 2]
+
+### Dependencies
+- [Dependency 1]
+- [Dependency 2]
+
+### Notes
+[Any concerns or observations]
+
+---
+Proceeding to PLAN phase...
+```
+
+## Gate
+`analyze_gate` - Must have read relevant files before proceeding to PLAN.
+
+## Arguments
+`$ARGUMENTS` - The topic or task to analyze
+
+## Examples
+- `/analyze user authentication` - Analyze auth implementation
+- `/analyze how routing works` - Analyze routing patterns
+- `/analyze add dark mode` - Analyze requirements for dark mode feature

package/.claude/commands/audit.md

@@ -0,0 +1,220 @@
+# /audit - Audit Command
+
+Run UI enforcement and circular dependency checks.
+
+## Trigger
+- User invokes `/audit`
+- User invokes `/audit project` (full project scan)
+- Or: Automatically after VERIFY phase (for features)
+- Or: Part of audit_loop
+
+## When Required
+Per `system/router.md`, audit is required for:
+- `feature` - New functionality
+- `refactor` - Code restructuring
+- `perf` - Performance changes
+
+## Arguments
+- `/audit` - Run standard UI + cycle checks
+- `/audit project` - Full project scan (generates/updates BLUEPRINT.md)
+
+---
+
+## Mode 1: Project Audit (Full Scan)
+
+When `/audit project` is invoked OR when BLUEPRINT.md is missing:
+
+### Step 1: Scan Codebase (Single Pass)
+```bash
+# All discovery commands run ONCE
+cat package.json | grep -A 30 "dependencies"
+find src -type d | head -30
+ls -la src/
+[ -d src/pages ] && ls src/pages/
+[ -d src/app ] && ls src/app/
+[ -d src/components ] && ls src/components/
+[ -d src/api ] && find src/api -name "*.ts"
+[ -d src/hooks ] && ls src/hooks/
+[ -f prisma/schema.prisma ] && cat prisma/schema.prisma
+grep -r "/api/" src/ | head -30
+```
+
+### Step 2: Present Dual Updates
+```
+## 🔍 Project Audit Complete
+
+### 📄 AI_RULES.md Updates
+
+**Tech Stack** (detected):
+- Framework: [detected]
+- Styling: [detected]
+- Database: [detected]
+
+**File Structure** (discovered):
+src/
+├── [directories found]
+└── [file counts]
+
+---
+
+### 📘 BLUEPRINT.md (will create/update)
+
+**Features Discovered:**
+| Feature | Frontend | Backend | Route | Status |
+|---------|----------|---------|-------|--------|
+| [name] | [component] | [api] | [route] | ✅/⚠️ |
+
+**⚠️ Issues Found:**
+- [Orphan APIs, unused hooks, etc.]
+
+---
+
+**Should I save these updates?**
+- AI_RULES.md → Update Tech Stack & File Structure
+- BLUEPRINT.md → Create/update with discoveries
+```
+
+### Step 3: Save After Approval
+Update both files with discovered information.
+
+---
+
+## Mode 2: Standard Audit (Default)
+
+## Workflow
+
+### Step 1: Run UI Enforcement
+```bash
+npm run audit:ui
+```
+
+Check for orphan features:
+- API endpoints without UI
+- Hooks not used by components
+- Utilities not imported anywhere
+- Routes without page components
+
+### Step 2: Run Circular Dependency Check
+```bash
+npm run audit:cycles
+```
+
+Check for import cycles:
+- A → B → A
+- A → B → C → A
+- Longer chains
+
+### Step 3: Report Results
+
+**On Success:**
+```
+## Audit
+
+✅ **ALL AUDITS PASSED**
+
+| Check | Status | Details |
+|-------|--------|---------|
+| UI Enforcement | ✅ | No orphan features |
+| Circular Deps | ✅ | No cycles detected |
+
+**Gate Status:** `audit_gate` ✅ PASSED
+
+Ready to proceed to COMMIT.
+```
+
+**On UI Failure:**
+```
+## Audit
+
+| Check | Status | Details |
+|-------|--------|---------|
+| UI Enforcement | ⛔ | Orphan features found |
+| Circular Deps | ✅ | No cycles |
+
+### Orphan Features Detected
+
+**API without UI:**
+- `/api/users` - No component calls this endpoint
+
+**Unused Hooks:**
+- `useAuth` - Not used by any component
+
+**Unreachable Routes:**
+- `/settings` - No navigation leads here
+
+**Gate Status:** `audit_gate` ⛔ BLOCKED
+
+---
+
+⛔ **BLOCKED: Cannot commit orphan features**
+
+Must add UI for each backend feature.
+
+### Required Actions
+1. Create `UserList.tsx` component for `/api/users`
+2. Use `useAuth` hook in `AuthProvider.tsx`
+3. Add navigation link to `/settings`
+
+Building missing UI components...
+```
+
+**On Cycle Failure:**
+```
+## Audit
+
+| Check | Status | Details |
+|-------|--------|---------|
+| UI Enforcement | ✅ | No orphans |
+| Circular Deps | ⛔ | Cycles detected |
+
+### Circular Dependencies Found
+
+**Cycle 1:**
+```
+src/hooks/useAuth.ts
+    → src/api/auth.ts
+    → src/hooks/useAuth.ts (CYCLE)
+```
+
+**Cycle 2:**
+```
+src/components/Button.tsx
+    → src/utils/helpers.ts
+    → src/components/Icon.tsx
+    → src/components/Button.tsx (CYCLE)
+```
+
+**Gate Status:** `audit_gate` ⛔ BLOCKED
+
+---
+
+⛔ **BLOCKED: Cannot commit with circular dependencies**
+
+### Required Actions
+1. Extract shared code from `useAuth` and `auth.ts`
+2. Break Button → Icon dependency
+
+Resolving cycles...
+```
+
+### Step 4: Fix Loop (if issues)
+Per `system/loops.md`:
+- `ui_fix_loop` - Build missing UI
+- `cycle_fix_loop` - Resolve import cycles
+
+## Gate
+`audit_gate` - Must pass before COMMIT for features.
+
+## Commands Used
+```bash
+npm run audit:ui      # UI enforcement check
+npm run audit:cycles  # Circular dependency check
+npm run audit:all     # Run all audits
+```
+
+## Loop Reference
+See `system/loops.md#audit_loop` for loop definition.
+
+## Examples
+- `/audit` - Run all audit checks
+- Automatic after verify passes (for features)

package/.claude/commands/build.md

@@ -0,0 +1,159 @@
+# /build - Build Feature Command
+
+Execute the full workflow to build a feature from start to finish.
+
+## Trigger
+- User invokes `/build [feature description]`
+
+## Workflow
+
+This command runs the **complete workflow** as defined in the system:
+
+```
+ANALYZE → PLAN+SUGGEST → CONFIRM → IMPLEMENT → VERIFY → AUDIT → COMMIT
+```
+
+### Phase 1: ANALYZE
+```
+1. Read: CLAUDE.md (entry point)
+2. Route: system/router.md → classify as "feature"
+3. Read: instructions/AI_RULES.md
+4. Read: instructions/BLUEPRINT.md
+5. Search: relevant existing code
+6. Report: analysis findings
+```
+
+**Trigger:** `on:task_received`
+
+### Phase 2: PLAN + SUGGEST
+```
+1. Design: implementation approach
+2. List: files to create/modify
+3. Generate: suggestions (required for features)
+4. Present: plan to user
+5. Ask: "Should I proceed? Which suggestions?"
+```
+
+**Gate:** `plan_approval_gate` - Wait for approval
+
+### Phase 3: IMPLEMENT
+```
+1. Create/modify: planned files
+2. Include: approved suggestions
+3. Follow: AI_RULES.md standards
+4. Ensure: no TODO/FIXME
+5. Ensure: no console.log
+6. Complete: UI + Backend together
+```
+
+**Trigger:** `on:implementation_complete`
+
+### Phase 4: VERIFY
+```
+1. Run: npm run verify
+2. Check: TypeScript errors
+3. Check: ESLint warnings
+4. If errors: enter fix_loop
+5. Repeat: until pass or max iterations
+```
+
+**Loop:** `verify_loop` (max 10 iterations)
+**Gate:** `verify_gate`
+
+### Phase 5: AUDIT
+```
+1. Run: npm run audit:ui
+2. Check: no orphan features
+3. Run: npm run audit:cycles
+4. Check: no circular dependencies
+5. If issues: fix and re-audit
+```
+
+**Loop:** `audit_loop` (max 5 iterations)
+**Gate:** `audit_gate`
+
+### Phase 6: COMMIT
+```
+1. Run: pre_commit_gate checks
+2. Show: commit preview
+3. Ask: user confirmation
+4. Execute: git commit
+5. Report: success
+```
+
+**Gate:** `pre_commit_gate`
+
+## Output Format
+
+```
+## Build: [feature description]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+### Phase 1: ANALYZE ✓
+[analysis findings]
+
+### Phase 2: PLAN
+[proposed changes + suggestions]
+
+**Should I proceed? Which suggestions?**
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+(after approval)
+
+### Phase 3: IMPLEMENT ✓
+[changes made]
+
+### Phase 4: VERIFY
+[verification results]
+Status: ✅ PASSED
+
+### Phase 5: AUDIT
+[audit results]
+Status: ✅ PASSED
+
+### Phase 6: COMMIT
+[pre-commit check]
+
+**Should I commit: "feat(scope): description"?**
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+(after approval)
+
+### Summary
+✅ Feature complete
+- Files created: X
+- Files modified: X
+- Suggestions included: [list]
+- Commit: [hash]
+```
+
+## Blocking Points
+
+The workflow will pause at:
+1. **Plan approval** - User must approve before implementing
+2. **Commit approval** - User must approve before committing
+
+The workflow will block (not pause) at:
+1. **Verification failures** - Must fix errors
+2. **Audit failures** - Must resolve issues
+3. **Pre-commit failures** - Must fix blocking items
+
+## Rules
+- MUST read instructions/AI_RULES.md before implementing
+- MUST show suggestions for new features
+- MUST ask which suggestions to include
+- CANNOT skip verification
+- CANNOT commit with errors
+- CANNOT commit orphan features (backend without UI)
+
+## Arguments
+`$ARGUMENTS` - Description of the feature to build
+
+## Examples
+- `/build user authentication with login and signup`
+- `/build dark mode toggle in settings`
+- `/build contact form with validation`
+- `/build dashboard with user stats`

package/.claude/commands/commit.md

@@ -0,0 +1,165 @@
+# /commit - Commit Command
+
+Run pre-commit gate and create a conventional commit.
+
+## Trigger
+- User invokes `/commit [message]`
+- Or: After AUDIT phase passes
+
+## Workflow
+
+### Step 1: Pre-Commit Gate
+Per `system/gates.md#pre_commit_gate`, check ALL requirements:
+
+```
+1. verify_gate passed (TypeScript + ESLint clean)
+2. audit_gate passed (if feature/refactor)
+3. No TODO/FIXME comments in changed files
+4. No console.log/debug/info in changed files
+5. Commit message follows conventional format
+```
+
+### Step 2: Check Changed Files
+```bash
+git diff --cached --name-only  # Staged files
+git diff --name-only           # Unstaged changes
+```
+
+Search for blocking patterns:
+```bash
+# Check for TODO/FIXME
+grep -rn "TODO\|FIXME\|XXX\|HACK" [changed files]
+
+# Check for console.log
+grep -rn "console\.\(log\|debug\|info\)" [changed files]
+```
+
+### Step 3: Validate Commit Message
+Format: `type(scope): description`
+
+Valid types:
+- `feat` - New feature
+- `fix` - Bug fix
+- `docs` - Documentation
+- `style` - Formatting
+- `refactor` - Code restructure
+- `perf` - Performance
+- `test` - Tests
+- `build` - Build system
+- `ci` - CI/CD
+- `chore` - Maintenance
+- `revert` - Revert commit
+
+### Step 4: Report Gate Status
+
+**On All Pass:**
+```
+## Pre-Commit Gate
+
+| Check | Status |
+|-------|--------|
+| TypeScript | ✅ 0 errors |
+| ESLint | ✅ 0 warnings |
+| UI Enforcement | ✅ No orphans |
+| Circular Deps | ✅ No cycles |
+| TODO/FIXME | ✅ None found |
+| console.log | ✅ None found |
+| Commit Format | ✅ Valid |
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✅ **ALL GATES PASSED**
+
+### Ready to Commit
+
+**Files:**
+- `src/components/Button.tsx` (modified)
+- `src/hooks/useAuth.ts` (new)
+- `src/pages/Login.tsx` (new)
+
+**Message:** `feat(auth): add login page with authentication hook`
+
+**Should I proceed with this commit?**
+```
+
+**On Any Failure:**
+```
+## Pre-Commit Gate
+
+| Check | Status |
+|-------|--------|
+| TypeScript | ✅ |
+| ESLint | ✅ |
+| UI Enforcement | ✅ |
+| Circular Deps | ✅ |
+| TODO/FIXME | ⛔ Found |
+| console.log | ⛔ Found |
+| Commit Format | ✅ |
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⛔ **COMMIT BLOCKED**
+
+### Issues Found
+
+**TODO/FIXME Comments:**
+- `src/utils/helpers.ts:42` - "TODO: implement validation"
+
+**Console Statements:**
+- `src/hooks/useAuth.ts:15` - console.log("debug")
+
+### Required Actions
+1. Remove TODO at helpers.ts:42
+2. Remove console.log at useAuth.ts:15
+
+Fixing blocking issues...
+```
+
+### Step 5: Execute Commit (after approval)
+```bash
+git add -A
+git commit -m "type(scope): description"
+```
+
+### Step 6: Confirm Success
+```
+## Commit Complete
+
+✅ **COMMITTED**
+
+**Hash:** abc1234
+**Message:** feat(auth): add login page
+**Files:** 3 changed
+
+**Branch:** main
+**Status:** Ready to push (if desired)
+```
+
+## Gate
+`pre_commit_gate` - All checks must pass. Non-negotiable.
+
+## Arguments
+`$ARGUMENTS` - The commit message
+
+If no message provided, Claude will suggest one based on changes.
+
+## Commit Message Examples
+- `feat(auth): add login page with OAuth support`
+- `fix(api): handle null response in user fetch`
+- `refactor(utils): extract date formatting helpers`
+- `docs(readme): add installation instructions`
+- `style(button): update hover state colors`
+
+## Rules
+- NEVER commit if typecheck fails
+- NEVER commit if ESLint has warnings
+- NEVER commit with TODO/FIXME comments
+- NEVER commit with console.log statements
+- NEVER commit orphan features (backend without UI)
+- ALWAYS run verification first
+- ALWAYS ask for confirmation before committing
+- ALWAYS use conventional commit format
+
+## Examples
+- `/commit feat(auth): add login page` - Commit with message
+- `/commit` - Claude suggests message based on changes