feat: standards-shaper now updates existing standards based on project

**Major Enhancement**: /standards-shaper intelligently updates existing standards

## Problem

Standards-shaper created generic standards that didn't match the project:
- ❌ Generic examples (Express when project uses Fastify)
- ❌ Wrong framework versions (React 17 when using React 18)
- ❌ Generic patterns not specific to project's tech stack
- ❌ Had to manually update all examples
- ❌ Standards became stale as project evolved

## Solution

standards-shaper now has two intelligent modes:

### Create Mode (No existing standards)
- Detects tech stack
- Generates standards with project-specific examples
- All examples match detected frameworks

### Update Mode (Existing standards found) ⭐ NEW
- Reads existing standard files
- Detects current tech stack
- Updates examples to match current stack
- Preserves structure and user customizations
- Adds project-specific patterns from codebase

## How It Works

**Update Process**:
```
1. Check: if [ -d "droidz/standards" ]; UPDATE mode
2. Detect: Find package.json, analyze imports, check configs
3. Read: Load each existing standard file
4. Update: Replace examples with project-specific ones
5. Report: Show what changed
```

**Example Update Flow**:
```markdown
Project detected: Express + TypeScript + Prisma + PostgreSQL

backend/api.md:
  Before: Generic REST examples
  After: Express + TypeScript + Prisma patterns

backend/database.md:
  Before: Generic SQL
  After: Prisma Client + PostgreSQL specific queries

frontend/components.md:
  Before: React class components
  After: React 18 hooks + Server Components

frontend/styling.md:
  Before: CSS Modules examples
  After: Tailwind CSS v4 patterns
```

## What Gets Updated

**All standards updated with project-specific patterns**:
- `error-handling.md` - Try-catch patterns from codebase
- `testing.md` - Jest/Vitest/Playwright from package.json
- `components.md` - React/Vue/Angular version-specific
- `styling.md` - Tailwind/styled-components/CSS Modules
- `state-management.md` - Redux/Zustand/Jotai patterns
- `api-design.md` - Express/Fastify/Hono/etc
- `database.md` - Prisma/TypeORM/Sequelize/Drizzle
- `authentication.md` - NextAuth/Passport/Lucia

## Benefits

**For Users**:
- ✅ Standards match actual tech stack
- ✅ Examples use real frameworks from project
- ✅ Can re-run to update when upgrading frameworks
- ✅ Standards evolve with project
- ✅ No manual updates needed

**For Teams**:
- ✅ New members see project-specific examples
- ✅ Standards reflect current architecture
- ✅ Consistency across codebase
- ✅ Framework upgrades reflected in standards

## Usage

```bash
# First time - creates standards
> /standards-shaper
AI: No standards found, creating...
AI: Detected Next.js 15 + React 18 + Prisma
✅ Created standards with Next.js 15 examples

# Later - after upgrading to React 19
> /standards-shaper
AI: Found existing standards, updating...
AI: Detected React 19 (upgraded from 18)
AI: Updating components.md with React 19 patterns...
✅ Updated standards to React 19
```

## Implementation Details

**Detection Logic**:
- Check for package.json dependencies
- Analyze import statements with Grep
- Read framework config files
- Identify versions and variants

**Update Logic**:
- Read existing standard structure
- Keep headings and organization
- Replace code examples with project-specific ones
- Add patterns found in codebase analysis
- Preserve any user customizations

**Intelligent Updates**:
- Only updates examples and patterns
- Preserves structure and explanations
- Maintains DO/DON'T sections
- Keeps user-added content

## Files Modified

- droid_cli/default/commands/standards-shaper.md (major update)
- claude/default/commands/standards-shaper.md (synced)

## Breaking Changes

None - backward compatible. Command works as before for new projects.

---

Closes #standards-update
Closes #project-specific-standards

Author: korallis

CHANGELOG.md

@@ -147,6 +147,93 @@ Without this, Factory CLI ignores the skill file completely.
 - `claude/default/skills/*/SKILL.md` (49 files updated, 1 already correct)
 - `droid_cli/default/skills/*/SKILL.md` (49 files updated, 1 already correct)
 
+## [4.7.0] - 2024-11-24
+
+### Changed
+- **standards-shaper Updates Existing Standards**: Command now intelligently updates existing standards based on project
+  - Detects tech stack and updates examples in existing standard files
+  - Replaces generic examples with project-specific patterns
+  - Preserves structure while updating content to match your frameworks
+  - Example: Updates `api.md` from generic REST to your Express+TypeScript+Prisma patterns
+  
+### Enhanced
+- **/standards-shaper command** now has two modes:
+  - **Create mode**: Generates new standards from scratch (if no standards exist)
+  - **Update mode**: Updates existing standards to match current project (if standards found)
+  
+### Technical Details
+
+**Update Mode Behavior**:
+```
+1. Check for existing standards
+2. Read each standard file
+3. Detect project tech stack (React, Next.js, Express, Prisma, etc.)
+4. Update examples in standards to match detected stack
+5. Add project-specific patterns from codebase analysis
+6. Preserve user customizations
+```
+
+**Example Update**:
+```markdown
+Before (generic in backend/api.md):
+app.get('/users/:id', async (req, res) => {
+  // Generic example
+})
+
+After (project-specific with detected Express + TypeScript + Prisma):
+app.get('/api/v1/users/:id', async (req: Request, res: Response) => {
+  const user = await prisma.user.findUnique({
+    where: { id: req.params.id }
+  });
+  if (!user) return res.status(404).json({ error: 'User not found' });
+  res.json(user);
+});
+```
+
+**What Gets Updated**:
+- `error-handling.md` - Updated with project's try-catch patterns
+- `testing.md` - Updated with detected test framework (Jest/Vitest/etc)
+- `components.md` - Updated with React/Vue/Angular version-specific patterns
+- `styling.md` - Updated with Tailwind/CSS-in-JS/etc found in project
+- `state-management.md` - Updated with Redux/Zustand/Pinia/etc patterns
+- `api-design.md` - Updated with Express/FastAPI/etc patterns
+- `database.md` - Updated with PostgreSQL/MongoDB/Prisma/etc examples
+- `authentication.md` - Updated with NextAuth/Passport/etc patterns
+
+### Impact
+- ✅ Standards now stay synchronized with project tech stack
+- ✅ Examples in standards match actual frameworks used
+- ✅ No more generic "best practices" - project-specific guidance
+- ✅ Standards evolve as project evolves
+- ✅ Can re-run `/standards-shaper` to update standards when upgrading frameworks
+
+### User Experience
+
+**Before v4.7.0**:
+```
+> /standards-shaper
+AI: Creates generic standards
+Result: backend/api.md has generic Express examples (but you use Fastify!)
+```
+
+**After v4.7.0**:
+```
+> /standards-shaper
+AI: Detected existing standards, updating...
+AI: Found Fastify + TypeScript + PostgreSQL
+AI: Updating api.md with Fastify patterns...
+
+Result: backend/api.md now has Fastify-specific examples matching your project!
+```
+
+**Output Shows Changes**:
+```
+✅ Updated api-design.md - Changed from Express to Fastify patterns
+✅ Updated database.md - Changed from generic SQL to PostgreSQL + node-postgres
+✅ Updated components.md - Changed from React 17 to React 18 patterns
+✅ Updated styling.md - Changed from CSS Modules to Tailwind CSS v4
+```
+
 ## [4.6.0] - 2024-11-24
 
 ### Added

droidz_installer/payloads/claude/default/commands/standards-shaper.md

@@ -142,30 +142,53 @@ Use Grep to find existing patterns:
 - API patterns: Grep "api|endpoint|route"
 ```
 
-### PHASE 4: Generate Standards Documents
+### PHASE 4: Generate/Update Standards Documents
 
-Create comprehensive standards files based on research and project analysis.
+Create or update comprehensive standards files based on research and project analysis.
 
-#### Step 4.1: Create directory structure
+#### Step 4.1: Check for existing standards
+
+First, check if standards already exist:
+
+```bash
+if [ -d "droidz/standards" ]; then
+  echo "✅ Found existing standards directory"
+  UPDATING_STANDARDS=true
+else
+  echo "📝 Creating new standards directory"
+  UPDATING_STANDARDS=false
+fi
+```
+
+**If updating existing standards**:
+- Read each existing standard file
+- Keep the structure but update examples to match detected tech stack
+- Add project-specific patterns found in codebase
+- Preserve any user customizations (check git diff if available)
+
+**If creating new standards**:
+- Generate from templates with project-specific content
+
+#### Step 4.2: Create/Update directory structure
 
 ```
 droidz/standards/
 ├── README.md
 ├── global/
 │   ├── coding-principles.md
-│   ├── error-handling.md
-│   ├── testing.md
+│   ├── error-handling.md       [UPDATE with project's error patterns]
+│   ├── testing.md               [UPDATE with detected test framework]
 │   ├── security.md
 │   └── performance.md
 ├── frontend/          [if frontend detected]
-│   ├── components.md
-│   ├── styling.md
-│   ├── state-management.md
+│   ├── components.md            [UPDATE with React/Vue/Angular patterns]
+│   ├── styling.md               [UPDATE with Tailwind/CSS-in-JS/etc]
+│   ├── state-management.md      [UPDATE with Redux/Zustand/Pinia/etc]
 │   └── routing.md
 ├── backend/           [if backend detected]
-│   ├── api-design.md
-│   ├── database.md
-│   ├── authentication.md
+│   ├── api-design.md            [UPDATE with Express/FastAPI/etc patterns]
+│   ├── database.md              [UPDATE with PostgreSQL/MongoDB/etc]
+│   ├── authentication.md        [UPDATE with NextAuth/Passport/etc]
 │   └── error-responses.md
 └── infrastructure/    [if scope includes it]
     ├── deployment.md
@@ -284,15 +307,53 @@ Each standard file should follow this format:
 - [Tools and linters]
 ```
 
-#### Step 4.3: Generate content for each standard
+#### Step 4.3: Generate/Update content for each standard
+
+For each standard file:
 
-For each standard file, include:
+**If updating existing standard**:
+1. Read current content
+2. Keep structure (headings, sections)
+3. Update examples to use detected frameworks
+4. Add patterns found in codebase analysis
+5. Replace generic examples with project-specific ones
+6. Preserve user customizations
 
+**Example Update Process for `backend/api.md`**:
+```javascript
+// Detected: Express + TypeScript + PostgreSQL
+
+// Before (generic):
+```
+app.get('/users/:id', async (req, res) => {
+  // Generic example
+})
+```
+
+// After (project-specific):
+```
+app.get('/api/v1/users/:id', async (req: Request, res: Response) => {
+  const user = await prisma.user.findUnique({
+    where: { id: req.params.id }
+  });
+  if (!user) return res.status(404).json({ error: 'User not found' });
+  res.json(user);
+});
+```
+
+**If creating new standard**, include:
 1. **Research-backed content** (if tools available)
 2. **Framework-specific patterns** (from detected tech stack)
 3. **Project-specific patterns** (from codebase analysis)
-4. **Concrete examples** (with actual code)
-5. **Clear dos and don'ts** (with explanations)
+4. **Concrete examples** (with actual code from the project)
+5. **Clear dos and don'ts** (with project-relevant explanations)
+
+**Critical**: Always use project's actual:
+- Framework versions (React 18, Next.js 15, etc.)
+- Database (PostgreSQL, MongoDB, etc.)
+- Testing framework (Jest, Vitest, Playwright, etc.)
+- Styling approach (Tailwind, CSS Modules, styled-components, etc.)
+- State management (Redux, Zustand, Jotai, etc.)
 
 ### PHASE 5: Create README.md
 
@@ -378,8 +439,59 @@ Standards should be updated when:
 
 ### PHASE 6: Inform User
 
-Output to user:
+Output to user (adjust based on whether updating or creating):
+
+**If updated existing standards**:
+```
+✅ Project standards updated successfully!
+
+📁 Standards Location: droidz/standards/
+
+📋 Updated Standards:
+
+Global:
+  ✅ error-handling.md - Updated with try-catch patterns from codebase
+  ✅ testing.md - Updated with Jest + React Testing Library examples
+  
+Frontend:
+  ✅ components.md - Updated with React 18 patterns
+  ✅ styling.md - Updated with Tailwind CSS v4 examples
+  ✅ state-management.md - Updated with Zustand patterns found in /src/store
+  
+Backend:
+  ✅ api-design.md - Updated with Express + TypeScript patterns
+  ✅ database.md - Updated with Prisma + PostgreSQL examples
+
+📊 Research Used:
+  ✅ Exa Code Context - React 18 best practices
+  ✅ Ref Documentation - Next.js 15 App Router
+  ✅ Codebase Analysis - Found 47 components, 12 API routes
+  ✅ Framework Knowledge - Next.js 15, PostgreSQL 16
+
+🔄 Changes Made:
+  • Replaced generic examples with Next.js 15 App Router patterns
+  • Added Server Components vs Client Components guidelines
+  • Updated API examples to match /app/api structure
+  • Database examples now use Prisma (found in project)
+  • Tailwind CSS v4 patterns (detected from config)
+
+💡 What Changed:
+  • All code examples now match your tech stack
+  • Patterns reflect your actual codebase structure
+  • DO/DON'T examples use your frameworks
+  • Standards are now project-specific, not generic
+
+💡 Next Steps:
+
+1. Review updated standards in droidz/standards/
+2. Verify examples match your coding style
+3. Add any team-specific conventions
+4. Standards will automatically guide all future development
+
+🔗 Workflow Guide: droidz/standards/RECOMMENDED_WORKFLOW.md
+```
 
+**If created new standards**:
 ```
 ✅ Project standards created successfully!