autoworkflow 3.1.5 → 3.6.0

package/.claude/commands/analyze.md

@@ -1,3 +1,22 @@
+---
+role: Technical Analyst
+skills_required: []
+output_schema:
+  task_description: string
+  classification: {type: enum[feature,fix,refactor,style,docs,test,query], workflow: array, gates: array}
+  relevant_files: [{path: string, reason: string}]
+  existing_patterns: array
+  blueprint_requirements: array
+  dependencies: array
+  notes: array
+guardrails:
+  - Always read BLUEPRINT.md if it exists
+  - Always classify task type using system/router.md
+  - Never skip to implementation without analysis
+  - Identify all relevant files before planning
+  - Note existing patterns to maintain consistency
+---
+
 # /analyze - Analyze Command
 
 Analyze the codebase for a given task or question.

package/.claude/commands/audit.md

@@ -1,7 +1,33 @@
+---
+role: Senior Code Reviewer
+skills_required:
+  - security.md
+  - code-review.md
+output_schema:
+  feature_name: string
+  issues: [{severity: enum[critical,high,medium,low], category: enum[security,performance,maintainability,correctness], file: string, line: number, message: string, suggestion: string}]
+  summary: string
+  score: number (0-100)
+  approval: boolean
+  blocking_issues: number
+guardrails:
+  - Prioritize security issues above all else
+  - Fail immediately on critical issues
+  - Always provide actionable fix suggestions
+  - ONE FEATURE AT A TIME - never audit multiple features simultaneously
+  - Complete full cycle before moving to next feature
+  - Require user confirmation before proceeding to next feature
+---
+
 # /audit - Audit Command
 
 Run code quality, security, and architecture audits.
 
+## Prerequisites (LOAD FIRST)
+**Before executing this command, READ these skill files:**
+1. `.claude/skills/security.md` - Security patterns and vulnerabilities
+2. `.claude/skills/code-review.md` - Code review checklist and feedback
+
 ## Trigger
 - User invokes `/audit`
 - User invokes `/audit project` (full project scan)

package/.claude/commands/build.md

@@ -1,7 +1,46 @@
+---
+role: Senior Full-Stack Engineer
+skills_required: []
+dynamic_skills:
+  - Detect project tech stack and load relevant skills
+  - React projects: react.md, nextjs-app-router.md or nextjs-pages.md
+  - Vue projects: vue.md, nuxt.md
+  - Backend: express.md, fastapi.md, etc.
+  - Database: prisma.md, postgresql.md, mongodb.md
+output_schema:
+  feature_name: string
+  workflow_phases: [analyze, plan, confirm, implement, verify, audit, commit]
+  current_phase: string
+  phase_outputs: object
+  final_status: enum[completed,blocked,pending_approval]
+guardrails:
+  - Execute FULL workflow: ANALYZE → PLAN → CONFIRM → IMPLEMENT → VERIFY → AUDIT → COMMIT
+  - NEVER skip the CONFIRM phase - always wait for user approval
+  - Handle loading, error, and empty states for all UI components
+  - Use TypeScript with proper type definitions
+  - Ensure accessibility (WCAG 2.1 AA minimum)
+  - Follow existing code patterns in the project
+---
+
 # /build - Build Feature Command
 
 Execute the full workflow to build a feature from start to finish.
 
+## Prerequisites (LOAD FIRST - Dynamic)
+**Before executing, detect project tech stack and load relevant skills:**
+
+1. **Check package.json** for dependencies
+2. **Load matching skills from `.claude/skills/`:**
+   - React → `react.md`
+   - Next.js (app router) → `nextjs-app-router.md`
+   - Next.js (pages) → `nextjs-pages.md`
+   - Vue → `vue.md`
+   - Prisma → `prisma.md`
+   - Express → `express.md`
+   - TypeScript → Check `tsconfig.json` patterns
+
+3. **Always load:** `security.md` for security awareness
+
 ## Trigger
 - User invokes `/build [feature description]`
 

package/.claude/commands/commit.md

@@ -1,7 +1,32 @@
+---
+role: Git Operations Specialist
+skills_required:
+  - git.md
+output_schema:
+  files_changed: array
+  commit_type: enum[feat,fix,docs,style,refactor,perf,test,build,ci,chore,revert]
+  commit_scope: string
+  commit_message: string
+  gate_status: {typescript: boolean, eslint: boolean, todo_check: boolean, console_check: boolean, format_valid: boolean}
+  commit_hash: string
+guardrails:
+  - ALWAYS use conventional commit format: type(scope): description
+  - NEVER commit with failing TypeScript or ESLint checks
+  - NEVER commit files containing TODO/FIXME comments
+  - NEVER commit files containing console.log statements
+  - NEVER force push to main/master branch
+  - ALWAYS run verification before committing
+  - ALWAYS ask for confirmation before executing commit
+---
+
 # /commit - Commit Command
 
 Run pre-commit gate and create a conventional commit.
 
+## Prerequisites (LOAD FIRST)
+**Before executing this command, READ these skill files:**
+1. `.claude/skills/git.md` - Git conventions, commit formats, and best practices
+
 ## Trigger
 - User invokes `/commit [message]`
 - Or: After AUDIT phase passes

package/.claude/commands/fix.md

@@ -1,7 +1,30 @@
+---
+role: Senior Debug Engineer
+skills_required:
+  - debugging.md
+output_schema:
+  diagnosis: {root_cause: string, error_type: string, affected_files: array}
+  fix: {approach: string, changes: [{file: string, description: string}], verification_steps: array}
+  prevention: {regression_test: string, recommendations: array}
+  iteration: number
+  status: enum[fixed,in_progress,stuck]
+guardrails:
+  - Make minimal, targeted changes only
+  - Always verify fix with npm run verify
+  - Never make destructive changes without confirmation
+  - Add regression test recommendation for each fix
+  - Follow systematic debugging: REPRODUCE → ISOLATE → IDENTIFY → FIX → VERIFY
+  - Max 10 fix iterations before asking for help
+---
+
 # /fix - Fix Command
 
 Fix verification errors and re-verify.
 
+## Prerequisites (LOAD FIRST)
+**Before executing this command, READ these skill files:**
+1. `.claude/skills/debugging.md` - Systematic debugging approach and techniques
+
 ## Trigger
 - User invokes `/fix`
 - Or: Automatically when `verify_loop` detects errors

package/.claude/commands/plan.md

@@ -1,3 +1,21 @@
+---
+role: Senior Technical Project Manager
+skills_required: []
+output_schema:
+  feature_name: string
+  classification: {type: string, workflow: string}
+  phases: [{name: string, tasks: array}]
+  tasks: [{id: string, description: string, effort: enum[S,M,L,XL], depends_on: array}]
+  risks: [{risk: string, mitigation: string}]
+  definition_of_done: array
+guardrails:
+  - Maximum 10 tasks per phase
+  - Always include effort estimates (S/M/L/XL)
+  - Always identify task dependencies
+  - Never implement without explicit user approval
+  - Break complex tasks into smaller steps
+---
+
 # /plan - Plan Command
 
 Create an implementation plan with suggestions.

package/.claude/commands/suggest.md

@@ -1,7 +1,30 @@
+---
+role: Technical Advisor
+skills_required:
+  - code-review.md
+output_schema:
+  task_name: string
+  suggestions:
+    required: [{description: string, reason: string}]
+    recommended: [{description: string, reason: string}]
+    optional: [{description: string, reason: string}]
+  user_selection: array
+guardrails:
+  - Categorize all suggestions by priority (required/recommended/optional)
+  - Always explain the "why" for each suggestion
+  - Required items are non-negotiable for feature completeness
+  - Let user select which suggestions to implement
+  - Never implement suggestions without user approval
+---
+
 # /suggest - Suggest Command
 
 Generate feature completeness suggestions for a task.
 
+## Prerequisites (LOAD FIRST)
+**Before executing this command, READ these skill files:**
+1. `.claude/skills/code-review.md` - Code review patterns and feedback templates
+
 ## Trigger
 - User invokes `/suggest [task]`
 - Or: Automatically during PLAN phase for features

package/.claude/commands/verify.md

@@ -1,3 +1,21 @@
+---
+role: Quality Assurance Engineer
+skills_required: []
+output_schema:
+  typescript: {status: enum[pass,fail], error_count: number, errors: array}
+  eslint: {status: enum[pass,fail], warning_count: number, warnings: array}
+  gate_passed: boolean
+  iteration: number
+  max_iterations: 10
+guardrails:
+  - Always run full verification (typecheck + lint)
+  - Report every error with file path and line number
+  - Auto-enter fix loop on any failure
+  - Maximum 10 fix iterations before escalating to user
+  - Never skip verification steps
+  - Clear reporting of gate status
+---
+
 # /verify - Verify Command
 
 Run TypeScript and ESLint verification with fix loop.

package/.claude/hooks/post-bash-router.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# AutoWorkflow Post-Bash Router Hook
+# Runs on: PostToolUse for Bash
+# Purpose: Route bash commands to appropriate post-action hooks
+#
+# Routes:
+# - git commit → post-commit.sh (BLUEPRINT update reminder)
+
+# Get the command that was executed
+TOOL_INPUT="$1"
+
+# Check if this was a git commit command
+if echo "$TOOL_INPUT" | grep -qE "git\s+commit"; then
+    # Route to post-commit hook
+    ./.claude/hooks/post-commit.sh
+    exit $?
+fi
+
+# No routing needed for other commands
+exit 0

package/.claude/hooks/post-commit.sh

@@ -0,0 +1,140 @@
+#!/bin/bash
+# AutoWorkflow Post-Commit Hook
+# Runs on: PostToolUse for Bash (when git commit detected)
+# Purpose: Trigger BLUEPRINT.md update reminder after feature commits
+#
+# This hook implements the on:feature_complete trigger
+# It reminds Claude to update BLUEPRINT.md after successful commits
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+DIM='\033[2m'
+NC='\033[0m'
+
+# State directory
+STATE_DIR=".claude/.autoworkflow"
+
+# State files
+PHASE_FILE="$STATE_DIR/phase"
+TASK_TYPE_FILE="$STATE_DIR/task-type"
+
+# Get task type
+get_task_type() {
+    if [ -f "$TASK_TYPE_FILE" ]; then
+        cat "$TASK_TYPE_FILE"
+    else
+        echo "unknown"
+    fi
+}
+
+# Check if task type requires BLUEPRINT update
+requires_blueprint_update() {
+    local task_type="$1"
+    case "$task_type" in
+        feature|refactor)
+            return 0
+            ;;
+        *)
+            return 1
+            ;;
+    esac
+}
+
+# Reset workflow state after commit
+reset_workflow() {
+    echo "IDLE" > "$PHASE_FILE"
+    rm -f "$STATE_DIR/verify-iteration" 2>/dev/null
+    rm -f "$STATE_DIR/verify-status" 2>/dev/null
+    rm -f "$STATE_DIR/plan-approved" 2>/dev/null
+    rm -f "$STATE_DIR/changed-files" 2>/dev/null
+    rm -f "$STATE_DIR/session-resumed" 2>/dev/null
+}
+
+# Get last commit info
+get_commit_info() {
+    local commit_type=$(git log -1 --pretty=%s 2>/dev/null | cut -d'(' -f1 | cut -d':' -f1)
+    local commit_scope=$(git log -1 --pretty=%s 2>/dev/null | sed -n 's/.*(\([^)]*\)).*/\1/p')
+    local commit_msg=$(git log -1 --pretty=%s 2>/dev/null)
+    local commit_hash=$(git log -1 --pretty=%h 2>/dev/null)
+    local files_changed=$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null | wc -l | tr -d ' ')
+
+    echo "$commit_type|$commit_scope|$commit_msg|$commit_hash|$files_changed"
+}
+
+# Main execution
+main() {
+    local task_type=$(get_task_type)
+    local commit_info=$(get_commit_info)
+    local commit_type=$(echo "$commit_info" | cut -d'|' -f1)
+    local commit_scope=$(echo "$commit_info" | cut -d'|' -f2)
+    local commit_msg=$(echo "$commit_info" | cut -d'|' -f3)
+    local commit_hash=$(echo "$commit_info" | cut -d'|' -f4)
+    local files_changed=$(echo "$commit_info" | cut -d'|' -f5)
+
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo -e "${GREEN}${BOLD}✅ AUTOWORKFLOW: COMMIT COMPLETE${NC}"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo -e "  ${CYAN}Hash:${NC}    $commit_hash"
+    echo -e "  ${CYAN}Message:${NC} $commit_msg"
+    echo -e "  ${CYAN}Files:${NC}   $files_changed changed"
+    echo ""
+
+    # Check if BLUEPRINT update is needed
+    if requires_blueprint_update "$task_type" || [ "$commit_type" = "feat" ] || [ "$commit_type" = "refactor" ]; then
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo -e "${YELLOW}${BOLD}📘 AUTOWORKFLOW: UPDATE PHASE${NC}"
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo ""
+        echo "This commit may have added new features/routes/APIs."
+        echo ""
+        echo -e "${BOLD}Check if BLUEPRINT.md needs updating:${NC}"
+        echo ""
+        echo "  1. New routes/pages added?"
+        echo "  2. New API endpoints added?"
+        echo "  3. New features/components added?"
+        echo "  4. Existing features modified?"
+        echo ""
+
+        # Check what might have changed
+        local new_routes=$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null | grep -E "(pages|app|routes)" | head -3)
+        local new_apis=$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null | grep -E "(api|endpoints|routes)" | head -3)
+        local new_components=$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null | grep -E "components" | head -3)
+
+        if [ -n "$new_routes" ]; then
+            echo -e "${DIM}Potential new routes:${NC}"
+            echo "$new_routes" | while read f; do echo -e "  ${DIM}- $f${NC}"; done
+            echo ""
+        fi
+
+        if [ -n "$new_apis" ]; then
+            echo -e "${DIM}Potential new APIs:${NC}"
+            echo "$new_apis" | while read f; do echo -e "  ${DIM}- $f${NC}"; done
+            echo ""
+        fi
+
+        if [ -n "$new_components" ]; then
+            echo -e "${DIM}Potential new components:${NC}"
+            echo "$new_components" | while read f; do echo -e "  ${DIM}- $f${NC}"; done
+            echo ""
+        fi
+
+        echo -e "${BOLD}Action:${NC} Review and update instructions/BLUEPRINT.md if needed."
+        echo ""
+        echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    fi
+
+    # Reset workflow state
+    reset_workflow
+
+    echo ""
+    echo -e "${GREEN}Workflow complete. Ready for next task.${NC}"
+    echo ""
+}
+
+main

package/.claude/hooks/post-edit.sh

@@ -86,27 +86,42 @@ print_header() {
     echo ""
 }
 
-# Run verification
-run_verify() {
+# Detect project type
+detect_project_type() {
+    if [ -f "package.json" ]; then
+        echo "node"
+    elif [ -f "composer.json" ]; then
+        echo "php"
+    elif [ -f "pyproject.toml" ] || [ -f "requirements.txt" ] || [ -f "setup.py" ]; then
+        echo "python"
+    elif [ -f "Cargo.toml" ]; then
+        echo "rust"
+    elif [ -f "go.mod" ]; then
+        echo "go"
+    elif [ -f "Gemfile" ]; then
+        echo "ruby"
+    elif [ -f "build.gradle" ] || [ -f "pom.xml" ]; then
+        echo "java"
+    else
+        echo "unknown"
+    fi
+}
+
+# Run verification for Node.js projects
+run_verify_node() {
     local has_verify=false
     local has_typecheck=false
     local has_lint=false
 
-    # Check what scripts are available
-    if [ -f "package.json" ]; then
-        grep -q '"verify"' package.json 2>/dev/null && has_verify=true
-        grep -q '"typecheck"' package.json 2>/dev/null && has_typecheck=true
-        grep -q '"lint"' package.json 2>/dev/null && has_lint=true
-    fi
+    grep -q '"verify"' package.json 2>/dev/null && has_verify=true
+    grep -q '"typecheck"' package.json 2>/dev/null && has_typecheck=true
+    grep -q '"lint"' package.json 2>/dev/null && has_lint=true
 
     if [ "$has_verify" = true ]; then
         echo -e "${CYAN}Running:${NC} npm run verify"
         echo ""
-        if npm run verify 2>&1; then
-            return 0
-        else
-            return 1
-        fi
+        npm run verify 2>&1
+        return $?
     elif [ "$has_typecheck" = true ] || [ "$has_lint" = true ]; then
         local exit_code=0
 
@@ -126,11 +141,169 @@ run_verify() {
         fi
 
         return $exit_code
-    else
-        echo -e "${YELLOW}⚠${NC} No verify/typecheck/lint scripts found in package.json"
-        echo "  Skipping verification."
-        return 0
     fi
+    return 0
+}
+
+# Run verification for PHP projects
+run_verify_php() {
+    local exit_code=0
+
+    # Check for PHPStan
+    if [ -f "phpstan.neon" ] || [ -f "phpstan.neon.dist" ] || grep -q '"phpstan"' composer.json 2>/dev/null; then
+        echo -e "${CYAN}Running:${NC} ./vendor/bin/phpstan analyse"
+        if ! ./vendor/bin/phpstan analyse 2>&1; then
+            exit_code=1
+        fi
+    fi
+
+    # Check for PHP CS Fixer or PHP_CodeSniffer
+    if [ -f ".php-cs-fixer.php" ] || [ -f ".php-cs-fixer.dist.php" ]; then
+        echo ""
+        echo -e "${CYAN}Running:${NC} ./vendor/bin/php-cs-fixer fix --dry-run --diff"
+        if ! ./vendor/bin/php-cs-fixer fix --dry-run --diff 2>&1; then
+            exit_code=1
+        fi
+    elif [ -f "phpcs.xml" ] || [ -f "phpcs.xml.dist" ]; then
+        echo ""
+        echo -e "${CYAN}Running:${NC} ./vendor/bin/phpcs"
+        if ! ./vendor/bin/phpcs 2>&1; then
+            exit_code=1
+        fi
+    fi
+
+    # Check for composer scripts
+    if grep -q '"test"' composer.json 2>/dev/null; then
+        echo ""
+        echo -e "${CYAN}Running:${NC} composer test"
+        if ! composer test 2>&1; then
+            exit_code=1
+        fi
+    fi
+
+    if [ $exit_code -eq 0 ] && ! grep -q '"phpstan"' composer.json 2>/dev/null && ! [ -f ".php-cs-fixer.php" ] && ! [ -f "phpcs.xml" ]; then
+        echo -e "${YELLOW}⚠${NC} No PHP verification tools detected (PHPStan, PHP-CS-Fixer, PHPCS)"
+        echo "  Consider adding: composer require --dev phpstan/phpstan"
+    fi
+
+    return $exit_code
+}
+
+# Run verification for Python projects
+run_verify_python() {
+    local exit_code=0
+
+    # Check for mypy
+    if [ -f "mypy.ini" ] || [ -f "setup.cfg" ] || [ -f "pyproject.toml" ]; then
+        if command -v mypy &> /dev/null; then
+            echo -e "${CYAN}Running:${NC} mypy ."
+            if ! mypy . 2>&1; then
+                exit_code=1
+            fi
+        fi
+    fi
+
+    # Check for ruff or flake8
+    if command -v ruff &> /dev/null; then
+        echo ""
+        echo -e "${CYAN}Running:${NC} ruff check ."
+        if ! ruff check . 2>&1; then
+            exit_code=1
+        fi
+    elif command -v flake8 &> /dev/null; then
+        echo ""
+        echo -e "${CYAN}Running:${NC} flake8 ."
+        if ! flake8 . 2>&1; then
+            exit_code=1
+        fi
+    fi
+
+    if [ $exit_code -eq 0 ] && ! command -v mypy &> /dev/null && ! command -v ruff &> /dev/null; then
+        echo -e "${YELLOW}⚠${NC} No Python verification tools detected (mypy, ruff, flake8)"
+        echo "  Consider adding: pip install mypy ruff"
+    fi
+
+    return $exit_code
+}
+
+# Run verification for Rust projects
+run_verify_rust() {
+    local exit_code=0
+
+    echo -e "${CYAN}Running:${NC} cargo check"
+    if ! cargo check 2>&1; then
+        exit_code=1
+    fi
+
+    echo ""
+    echo -e "${CYAN}Running:${NC} cargo clippy"
+    if ! cargo clippy -- -D warnings 2>&1; then
+        exit_code=1
+    fi
+
+    return $exit_code
+}
+
+# Run verification for Go projects
+run_verify_go() {
+    local exit_code=0
+
+    echo -e "${CYAN}Running:${NC} go build ./..."
+    if ! go build ./... 2>&1; then
+        exit_code=1
+    fi
+
+    echo ""
+    echo -e "${CYAN}Running:${NC} go vet ./..."
+    if ! go vet ./... 2>&1; then
+        exit_code=1
+    fi
+
+    if command -v golangci-lint &> /dev/null; then
+        echo ""
+        echo -e "${CYAN}Running:${NC} golangci-lint run"
+        if ! golangci-lint run 2>&1; then
+            exit_code=1
+        fi
+    fi
+
+    return $exit_code
+}
+
+# Run verification based on project type
+run_verify() {
+    local project_type=$(detect_project_type)
+
+    echo -e "${DIM}Detected project type: ${project_type}${NC}"
+    echo ""
+
+    case "$project_type" in
+        node)
+            run_verify_node
+            return $?
+            ;;
+        php)
+            run_verify_php
+            return $?
+            ;;
+        python)
+            run_verify_python
+            return $?
+            ;;
+        rust)
+            run_verify_rust
+            return $?
+            ;;
+        go)
+            run_verify_go
+            return $?
+            ;;
+        *)
+            echo -e "${YELLOW}⚠${NC} Unknown project type - no verification available"
+            echo "  Supported: Node.js, PHP, Python, Rust, Go"
+            return 0
+            ;;
+    esac
 }
 
 # Main execution