autoworkflow 3.8.4 → 3.9.1

package/.claude/.autoworkflow/memories/.gitkeep

@@ -0,0 +1,2 @@
+# Keep this directory in git
+# Memory files are gitignored by default but templates are kept

package/.claude/.autoworkflow/memories/blockers.md

@@ -0,0 +1,15 @@
+# Blockers
+
+> Known issues and workarounds. Claude edits directly.
+
+---
+
+## Template
+*YYYY-MM-DD*
+
+**Issue:** What is the problem?
+**Workaround:** How to work around it?
+**Status:** Open / Resolved
+
+---
+

package/.claude/.autoworkflow/memories/decisions.md

@@ -0,0 +1,15 @@
+# Decisions
+
+> Architectural and implementation choices. Claude edits directly.
+
+---
+
+## Template
+*YYYY-MM-DD*
+
+**Context:** What was the situation?
+**Decision:** What was chosen and why?
+**Implications:** What does this mean going forward?
+
+---
+

package/.claude/.autoworkflow/memories/patterns.md

@@ -0,0 +1,15 @@
+# Patterns
+
+> Discovered codebase patterns. Claude edits directly.
+
+---
+
+## Template
+*YYYY-MM-DD*
+
+**Pattern:** What is this pattern?
+**Where:** Which files/components use it?
+**Usage:** When and how to use it?
+
+---
+

package/.claude/commands/audit.md

@@ -32,10 +32,11 @@ Run code quality, security, and architecture audits.
 - User invokes `/audit`
 - User invokes `/audit project` (full project scan)
 - User invokes `/audit [feature]` (audit specific feature)
-- **AUTOMATIC:** When BLUEPRINT.md is missing at session start
 - Or: Automatically after VERIFY phase (for features)
 - Or: Part of audit_loop
 
+**Note:** When BLUEPRINT.md is missing, the system prompts user for documentation first.
+
 ## When Required
 Per `system/router.md`, audit is required for:
 - `feature` - New functionality
@@ -44,8 +45,8 @@ Per `system/router.md`, audit is required for:
 
 ## Arguments
 - `/audit` - Run standard checks (UI + cycles)
-- `/audit project` - Full project scan (generates BLUEPRINT.md)
-- `/audit sync` - Compare BLUEPRINT vs code, one feature at a time
+- `/audit project` - Full project scan (technical context)
+- `/audit sync` - Compare user's documentation vs code, one feature at a time
 - `/audit [feature name]` - Deep audit of specific feature
 
 ---
@@ -194,13 +195,12 @@ Based on the issues found, I recommend:
 
 ### Type 2: Project Audit (`/audit project`)
 
-When `/audit project` is invoked OR when BLUEPRINT.md is missing:
+When user explicitly invokes `/audit project`:
 
-**IMPORTANT:** When triggered by missing BLUEPRINT.md, this runs AUTOMATICALLY.
-- Do NOT ask "Should I run the audit?"
-- Do NOT wait for permission to start
-- Just notify and run immediately
-- Only ask permission when presenting results to SAVE
+**IMPORTANT:** This is a user-initiated scan for technical context.
+- Scans codebase structure, tech stack, routes, components, APIs
+- Outputs technical context to supplement user-provided documentation
+- Does NOT auto-generate BLUEPRINT.md - user must provide their docs first
 
 #### Step 1: Scan Codebase (Single Pass)
 ```bash
@@ -235,9 +235,8 @@ src/
 
 ---
 
-### 📘 BLUEPRINT.md (will create/update)
+### 📋 Features Discovered
 
-**Features Discovered:**
 | Feature | Frontend | Backend | Route | Status |
 |---------|----------|---------|-------|--------|
 | [name] | [component] | [api] | [route] | ✅/⚠️ |
@@ -247,33 +246,32 @@ src/
 
 ---
 
-**Should I save these updates?**
-- AI_RULES.md → Update Tech Stack & File Structure
-- BLUEPRINT.md → Create/update with discoveries
+**Should I save AI_RULES.md updates?**
+(Tech Stack & File Structure)
 ```
 
 #### Step 3: Save After Approval
-Update both files with discovered information.
+Update AI_RULES.md with discovered technical context.
 
 ---
 
-### Type 3: Blueprint Sync (`/audit sync`)
+### Type 3: Documentation Sync (`/audit sync`)
 
-Compare BLUEPRINT.md against actual code, **one feature at a time**.
+Compare user's documentation against actual code, **one feature at a time**.
 
-#### Step 1: Parse BLUEPRINT.md
-Extract features list from the Features section.
+#### Step 1: Parse User's Documentation
+Extract features list from the user's PRD/spec/userflow.
 
 #### Step 2: For EACH Feature (Serial)
 
 ```
 Feature 1: [Name]
     ↓
-Read BLUEPRINT requirements for this feature
+Read requirements from user's documentation
     ↓
 Scan code for this feature's implementation
     ↓
-Compare: BLUEPRINT ↔ Code
+Compare: Documentation ↔ Code
     ↓
 Report gaps (one feature only)
     ↓
@@ -289,11 +287,11 @@ THEN → Feature 2
 #### Step 3: Report Format (Per Feature)
 
 ```
-## Blueprint Sync: Feature 1 of 5
+## Documentation Sync: Feature 1 of 5
 
 ### 📘 User Authentication
 
-**BLUEPRINT says:**
+**Documentation says:**
 - Login with email/password
 - OAuth (Google, GitHub)
 - Password reset flow
@@ -314,8 +312,8 @@ THEN → Feature 2
 
 | Gap | Direction | Action |
 |-----|-----------|--------|
-| OAuth GitHub | 📘→💻 | In BLUEPRINT, not in code |
-| Password reset email | 📘→💻 | Incomplete implementation |
+| OAuth GitHub | 📄→💻 | In docs, not in code |
+| Password reset email | 📄→💻 | Incomplete implementation |
 
 ### Suggested Actions
 
@@ -326,23 +324,23 @@ THEN → Feature 2
 
 **Options:**
 - `implement` - Build missing code
-- `remove` - Remove from BLUEPRINT (if not needed)
+- `descope` - Mark as out of scope for now
 - `skip` - Move to next feature
 - `1` - Only action 1
 ```
 
 #### Step 4: After User Action
 - If `implement`: Build the missing parts, verify, re-check
-- If `remove`: Update BLUEPRINT.md to remove the item
+- If `descope`: Note as out of scope, move to next feature
 - If `skip`: Log as skipped, move to next feature
 
 #### Step 5: Next Feature
-Only after current feature is resolved (fixed/skipped/removed), show next:
+Only after current feature is resolved (fixed/skipped/descoped), show next:
 
 ```
 ✅ Feature 1: User Authentication - SYNCED
 
-## Blueprint Sync: Feature 2 of 5
+## Documentation Sync: Feature 2 of 5
 
 ### 📘 Dashboard...
 ```

package/.claude/commands/init.md

@@ -115,11 +115,12 @@ npm run setup:hooks
 - commit-msg
 
 **Next steps:**
-1. Edit `instructions/AI_RULES.md` with your coding standards
-2. Edit `instructions/BLUEPRINT.md` with your project spec
-3. Start using Claude Code - it will follow the workflow!
+1. Provide your project documentation (PRD, spec, userflow, or describe your project)
+2. Your documentation = single source of truth (used directly, no transformation)
+3. Edit `instructions/AI_RULES.md` with your coding standards
+4. Start using Claude Code - it will follow the workflow!
 
-Run `/audit project` to auto-generate BLUEPRINT.md from your codebase.
+**Tip:** Run `/audit project` to scan your codebase for technical context.
 ```
 
 ## Arguments

package/.claude/hooks/blueprint-generator.sh

@@ -30,13 +30,164 @@ print_header() {
     echo -e "${BOLD}AUTOWORKFLOW: PROJECT AUDIT${NC}"
     echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     echo ""
-    echo "Scanning project to generate BLUEPRINT.md..."
+}
+
+# Mode selection based on arguments
+select_mode() {
+    local mode="$1"
+
+    case "$mode" in
+        --from-docs)
+            echo "Mode: Generate BLUEPRINT from user-provided documentation"
+            echo ""
+            echo -e "${CYAN}I will read your provided docs and generate:${NC}"
+            echo "  • instructions/BLUEPRINT.md (feature tracking)"
+            echo "  • instructions/AI_RULES.md (coding standards)"
+            echo ""
+            echo -e "${YELLOW}Please provide the path to your documentation:${NC}"
+            echo "  • PRD, spec, userflow, or implementation guide"
+            echo "  • Or paste the content directly"
+            echo ""
+            ;;
+        --scan)
+            echo "Mode: Scan existing codebase"
+            echo ""
+            echo "Scanning project structure to supplement your documentation..."
+            echo ""
+            ;;
+        --interactive)
+            echo "Mode: Interactive specification builder"
+            echo ""
+            echo -e "${CYAN}I'll help you create a BLUEPRINT.md by asking questions:${NC}"
+            echo ""
+            echo "  1. What is this project? (brief description)"
+            echo "  2. What are the main features?"
+            echo "  3. What's the tech stack?"
+            echo "  4. Are there any specific requirements?"
+            echo ""
+            echo -e "${DIM}Answer these and I'll generate your specification.${NC}"
+            echo ""
+            ;;
+        *)
+            echo "Scanning project to supplement your documentation..."
+            echo ""
+            ;;
+    esac
+}
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# ENHANCED DISCOVERY (Serena-inspired)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+# Detect architecture pattern
+detect_architecture() {
+    echo -e "${CYAN}[0/8]${NC} Detecting architecture pattern..."
+
+    local pattern="unknown"
+
+    # Monorepo detection
+    if [ -f "pnpm-workspace.yaml" ] || [ -f "lerna.json" ] || [ -d "packages" ]; then
+        pattern="monorepo"
+        echo "  Pattern: Monorepo"
+        if [ -d "packages" ]; then
+            echo "  Packages:"
+            ls -1 packages/ 2>/dev/null | head -5 | while read -r pkg; do
+                echo "    - $pkg"
+            done
+        fi
+    # Microservices detection
+    elif [ -f "docker-compose.yml" ] && [ -d "services" ]; then
+        pattern="microservices"
+        echo "  Pattern: Microservices"
+        echo "  Services:"
+        ls -1 services/ 2>/dev/null | head -5 | while read -r svc; do
+            echo "    - $svc"
+        done
+    # Modular monolith detection
+    elif [ -d "src/modules" ] || [ -d "src/domains" ]; then
+        pattern="modular-monolith"
+        echo "  Pattern: Modular Monolith"
+        local mod_dir="src/modules"
+        [ -d "src/domains" ] && mod_dir="src/domains"
+        echo "  Modules:"
+        ls -1 "$mod_dir" 2>/dev/null | head -5 | while read -r mod; do
+            echo "    - $mod"
+        done
+    # Feature-based structure
+    elif [ -d "src/features" ]; then
+        pattern="feature-based"
+        echo "  Pattern: Feature-based"
+        echo "  Features:"
+        ls -1 src/features/ 2>/dev/null | head -5 | while read -r feat; do
+            echo "    - $feat"
+        done
+    # Standard layered
+    else
+        pattern="layered"
+        echo "  Pattern: Standard Layered"
+    fi
+
     echo ""
+
+    # Save to scan output
+    echo "architecture=$pattern" >> "$SCAN_OUTPUT"
 }
 
-# Detect tech stack from package.json
+# Detect essential commands from package.json
+detect_essential_commands() {
+    echo -e "${CYAN}[1/8]${NC} Detecting essential commands..."
+
+    if [ -f "package.json" ]; then
+        echo "  Available npm scripts:"
+
+        # Common important scripts
+        for script in "dev" "start" "build" "test" "lint" "format" "typecheck" "verify"; do
+            if grep -q "\"$script\":" package.json 2>/dev/null; then
+                local cmd=$(grep "\"$script\":" package.json | head -1 | sed 's/.*": "\(.*\)".*/\1/' | cut -c1-50)
+                echo -e "    ${GREEN}✓${NC} npm run $script"
+            fi
+        done
+
+        # Check for custom/project-specific scripts
+        echo ""
+        echo "  Other scripts:"
+        grep '"[a-z].*":' package.json 2>/dev/null | grep -v '"name"\|"version"\|"description"\|"main"\|"module"\|"types"\|"license"' | head -10 | while read -r line; do
+            local script_name=$(echo "$line" | sed 's/.*"\([^"]*\)".*/\1/')
+            case "$script_name" in
+                dev|start|build|test|lint|format|typecheck|verify) ;;
+                *) echo "    - npm run $script_name" ;;
+            esac
+        done
+        echo ""
+    fi
+
+    # Check for Makefile
+    if [ -f "Makefile" ]; then
+        echo "  Makefile targets:"
+        grep '^[a-zA-Z].*:' Makefile 2>/dev/null | head -5 | while read -r line; do
+            local target=$(echo "$line" | cut -d: -f1)
+            echo "    - make $target"
+        done
+        echo ""
+    fi
+
+    # Check for common tools
+    echo "  Tool configuration detected:"
+    [ -f ".eslintrc.js" ] || [ -f ".eslintrc.json" ] || [ -f "eslint.config.js" ] && echo "    - ESLint"
+    [ -f ".prettierrc" ] || [ -f "prettier.config.js" ] && echo "    - Prettier"
+    [ -f "tsconfig.json" ] && echo "    - TypeScript"
+    [ -f "jest.config.js" ] || [ -f "jest.config.ts" ] && echo "    - Jest"
+    [ -f "vitest.config.ts" ] && echo "    - Vitest"
+    [ -f "playwright.config.ts" ] && echo "    - Playwright"
+    [ -f "cypress.config.ts" ] || [ -f "cypress.config.js" ] && echo "    - Cypress"
+    [ -f ".github/workflows" ] && echo "    - GitHub Actions"
+    [ -f "Dockerfile" ] && echo "    - Docker"
+    echo ""
+}
+
+# Detect tech stack from package.json (enhanced)
 detect_tech_stack() {
-    echo -e "${CYAN}[1/6]${NC} Detecting tech stack..."
+    echo -e "${CYAN}[2/8]${NC} Detecting tech stack..."
 
     if [ -f "package.json" ]; then
         echo "  Found: package.json"
@@ -44,14 +195,26 @@ detect_tech_stack() {
         # Detect framework
         if grep -q '"next"' package.json 2>/dev/null; then
             echo "  Framework: Next.js"
+            # Detect Next.js version for App vs Pages router
+            if [ -d "app" ] || [ -d "src/app" ]; then
+                echo "    → App Router (Next.js 13+)"
+            elif [ -d "pages" ] || [ -d "src/pages" ]; then
+                echo "    → Pages Router"
+            fi
         elif grep -q '"react"' package.json 2>/dev/null; then
             echo "  Framework: React"
         elif grep -q '"vue"' package.json 2>/dev/null; then
             echo "  Framework: Vue"
+            grep -q '"nuxt"' package.json 2>/dev/null && echo "    → with Nuxt"
         elif grep -q '"svelte"' package.json 2>/dev/null; then
             echo "  Framework: Svelte"
+            grep -q '"@sveltejs/kit"' package.json 2>/dev/null && echo "    → with SvelteKit"
         elif grep -q '"express"' package.json 2>/dev/null; then
             echo "  Framework: Express"
+        elif grep -q '"fastify"' package.json 2>/dev/null; then
+            echo "  Framework: Fastify"
+        elif grep -q '"hono"' package.json 2>/dev/null; then
+            echo "  Framework: Hono"
         fi
 
         # Detect styling
@@ -63,20 +226,42 @@ detect_tech_stack() {
             echo "  Styling: Emotion"
         fi
 
-        # Detect database
+        # Detect database/ORM
         if grep -q '"prisma"' package.json 2>/dev/null; then
             echo "  Database: Prisma"
+        elif grep -q '"drizzle-orm"' package.json 2>/dev/null; then
+            echo "  Database: Drizzle ORM"
+        elif grep -q '"typeorm"' package.json 2>/dev/null; then
+            echo "  Database: TypeORM"
         elif grep -q '"mongoose"' package.json 2>/dev/null; then
             echo "  Database: MongoDB (Mongoose)"
         elif grep -q '"pg"' package.json 2>/dev/null; then
             echo "  Database: PostgreSQL"
         fi
 
+        # Detect state management
+        if grep -q '"zustand"' package.json 2>/dev/null; then
+            echo "  State: Zustand"
+        elif grep -q '"@reduxjs/toolkit"' package.json 2>/dev/null; then
+            echo "  State: Redux Toolkit"
+        elif grep -q '"jotai"' package.json 2>/dev/null; then
+            echo "  State: Jotai"
+        elif grep -q '"@tanstack/react-query"' package.json 2>/dev/null; then
+            echo "  State: TanStack Query"
+        fi
+
         # Detect TypeScript
         if grep -q '"typescript"' package.json 2>/dev/null; then
             echo "  Language: TypeScript"
         fi
 
+        # Detect testing framework
+        if grep -q '"vitest"' package.json 2>/dev/null; then
+            echo "  Testing: Vitest"
+        elif grep -q '"jest"' package.json 2>/dev/null; then
+            echo "  Testing: Jest"
+        fi
+
         echo ""
     else
         echo "  No package.json found"
@@ -86,7 +271,7 @@ detect_tech_stack() {
 
 # Scan project structure
 scan_structure() {
-    echo -e "${CYAN}[2/6]${NC} Scanning project structure..."
+    echo -e "${CYAN}[3/8]${NC} Scanning project structure..."
 
     # Find source directory
     if [ -d "src" ]; then
@@ -106,7 +291,7 @@ scan_structure() {
 
 # Scan for routes/pages
 scan_routes() {
-    echo -e "${CYAN}[3/6]${NC} Scanning routes..."
+    echo -e "${CYAN}[4/8]${NC} Scanning routes..."
 
     local found=false
 
@@ -147,7 +332,7 @@ scan_routes() {
 
 # Scan for components
 scan_components() {
-    echo -e "${CYAN}[4/6]${NC} Scanning components..."
+    echo -e "${CYAN}[5/8]${NC} Scanning components..."
 
     local comp_dir=""
     [ -d "src/components" ] && comp_dir="src/components"
@@ -170,7 +355,7 @@ scan_components() {
 
 # Scan for API endpoints
 scan_api() {
-    echo -e "${CYAN}[5/6]${NC} Scanning API endpoints..."
+    echo -e "${CYAN}[6/8]${NC} Scanning API endpoints..."
 
     local api_dir=""
     [ -d "src/app/api" ] && api_dir="src/app/api"
@@ -195,7 +380,7 @@ scan_api() {
 
 # Scan for hooks
 scan_hooks() {
-    echo -e "${CYAN}[6/6]${NC} Scanning custom hooks..."
+    echo -e "${CYAN}[7/8]${NC} Scanning custom hooks..."
 
     local hooks_dir=""
     [ -d "src/hooks" ] && hooks_dir="src/hooks"
@@ -216,41 +401,118 @@ scan_hooks() {
     echo ""
 }
 
+# Scan for environment and configuration (Serena-inspired onboarding)
+scan_environment() {
+    echo -e "${CYAN}[8/8]${NC} Scanning environment and configuration..."
+
+    # Check for env files
+    echo "  Environment files:"
+    [ -f ".env" ] && echo "    - .env (⚠️ ensure not committed)"
+    [ -f ".env.local" ] && echo "    - .env.local"
+    [ -f ".env.example" ] && echo "    - .env.example (template)"
+    [ -f ".env.development" ] && echo "    - .env.development"
+    [ -f ".env.production" ] && echo "    - .env.production"
+
+    # Extract env var names from .env.example if it exists
+    if [ -f ".env.example" ]; then
+        echo ""
+        echo "  Required environment variables:"
+        grep -v '^#' .env.example 2>/dev/null | grep '=' | cut -d= -f1 | head -10 | while read -r var; do
+            echo "    - $var"
+        done
+    fi
+
+    # Check for common config files
+    echo ""
+    echo "  Configuration files:"
+    [ -f "next.config.js" ] || [ -f "next.config.mjs" ] && echo "    - Next.js config"
+    [ -f "vite.config.ts" ] && echo "    - Vite config"
+    [ -f "tailwind.config.js" ] || [ -f "tailwind.config.ts" ] && echo "    - Tailwind config"
+    [ -f "drizzle.config.ts" ] && echo "    - Drizzle config"
+    [ -f "prisma/schema.prisma" ] && echo "    - Prisma schema"
+
+    echo ""
+}
+
 # Generate summary
 generate_summary() {
     echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    echo -e "${GREEN}${BOLD}🔍 AUDIT COMPLETE${NC}"
+    echo -e "${GREEN}${BOLD}🔍 SCAN COMPLETE${NC}"
     echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     echo ""
-    echo "Based on this scan, I will generate:"
+    echo "This scan provides technical context about your codebase."
     echo ""
-    echo "  📄 instructions/AI_RULES.md"
-    echo "     - Tech Stack section (detected above)"
-    echo "     - File Structure section"
+    echo -e "${YELLOW}${BOLD}To generate BLUEPRINT.md, I need your input:${NC}"
     echo ""
-    echo "  📘 instructions/BLUEPRINT.md"
-    echo "     - Features table (routes + components + APIs)"
-    echo "     - Routes section"
-    echo "     - API endpoints section"
+    echo "  ${CYAN}Option 1:${NC} Provide existing documentation"
+    echo "    Share your PRD, spec, userflow, or implementation guide"
     echo ""
-    echo -e "${YELLOW}${BOLD}Should I save these files?${NC} (yes/no/edit first)"
+    echo "  ${CYAN}Option 2:${NC} Answer a few questions"
+    echo "    • What does this project do?"
+    echo "    • What are the main features/user flows?"
+    echo "    • Any specific requirements or constraints?"
+    echo ""
+    echo "  ${CYAN}Option 3:${NC} Just describe your project"
+    echo "    Tell me about it in plain language"
+    echo ""
+    echo -e "${DIM}I'll combine your input with this technical scan to generate:${NC}"
+    echo "  📄 instructions/AI_RULES.md (tech stack, coding standards)"
+    echo "  📘 instructions/BLUEPRINT.md (features, requirements, tracking)"
     echo ""
 }
 
 # Main execution
 main() {
+    local mode="${1:-}"
+
     print_header
 
-    # Run all scans
+    # Handle different modes
+    case "$mode" in
+        --from-docs)
+            select_mode "--from-docs"
+            exit 0
+            ;;
+        --interactive)
+            select_mode "--interactive"
+            exit 0
+            ;;
+        --help)
+            echo "Usage: blueprint-generator.sh [mode]"
+            echo ""
+            echo "Modes:"
+            echo "  (no args)      Scan codebase for technical context"
+            echo "  --from-docs    Generate from user-provided documentation"
+            echo "  --interactive  Build specification through Q&A"
+            echo "  --help         Show this help"
+            echo ""
+            exit 0
+            ;;
+    esac
+
+    # Default: Scan mode
+    echo "Scanning project for technical context..."
+    echo "(This supplements your documentation, not replaces it)"
+    echo ""
+
+    # Initialize scan output
+    echo "# Project Scan Results" > "$SCAN_OUTPUT"
+    echo "Generated: $(date)" >> "$SCAN_OUTPUT"
+    echo "" >> "$SCAN_OUTPUT"
+
+    # Run all scans (Serena-inspired comprehensive discovery)
+    detect_architecture
+    detect_essential_commands
     detect_tech_stack
     scan_structure
     scan_routes
     scan_components
     scan_api
     scan_hooks
+    scan_environment
 
-    # Generate summary
+    # Generate summary - asks for user input
     generate_summary
 }
 
-main
+main "$@"