claude-code-starter 0.9.0 → 0.11.0

package/dist/cli.js

@@ -533,3055 +533,111 @@ function summarizeTechStack(stack) {
 // src/generator.ts
 import fs2 from "fs";
 import path2 from "path";
-function generateArtifacts(projectInfo) {
-  const artifacts = [];
-  const { techStack, rootDir } = projectInfo;
-  artifacts.push(generateSettings(techStack));
-  artifacts.push(...generateSkills(techStack));
-  artifacts.push(...generateAgents(techStack));
-  artifacts.push(...generateRules(techStack));
-  artifacts.push(...generateCommands());
-  for (const artifact of artifacts) {
-    const fullPath = path2.join(rootDir, artifact.path);
-    artifact.isNew = !fs2.existsSync(fullPath);
-  }
-  const summary = {
-    created: artifacts.filter((a) => a.isNew).length,
-    updated: artifacts.filter((a) => !a.isNew).length,
-    skipped: 0
-  };
-  return { artifacts, summary };
-}
-function writeArtifacts(artifacts, rootDir, force) {
-  const created = [];
-  const updated = [];
-  const skipped = [];
-  for (const artifact of artifacts) {
-    const fullPath = path2.join(rootDir, artifact.path);
-    const dir = path2.dirname(fullPath);
-    fs2.mkdirSync(dir, { recursive: true });
-    const exists = fs2.existsSync(fullPath);
-    if (exists && !force) {
-      const shouldPreserve = artifact.path.includes("state/task.md");
-      if (shouldPreserve) {
-        skipped.push(artifact.path);
-        continue;
-      }
-    }
-    fs2.writeFileSync(fullPath, artifact.content);
-    if (exists) {
-      updated.push(artifact.path);
-    } else {
-      created.push(artifact.path);
-    }
+function ensureDirectories(rootDir) {
+  const dirs = [
+    ".claude",
+    ".claude/skills",
+    ".claude/agents",
+    ".claude/rules",
+    ".claude/commands",
+    ".claude/state"
+  ];
+  for (const dir of dirs) {
+    fs2.mkdirSync(path2.join(rootDir, dir), { recursive: true });
   }
-  return { created, updated, skipped };
 }
 function generateSettings(stack) {
-  const permissions = ["Read(**)", "Edit(**)", "Write(.claude/**)", "Bash(git:*)"];
-  const pkgManagers = ["npm", "yarn", "pnpm", "bun", "npx"];
-  for (const pm of pkgManagers) {
-    permissions.push(`Bash(${pm}:*)`);
-  }
-  if (stack.languages.includes("typescript") || stack.languages.includes("javascript")) {
-    permissions.push("Bash(node:*)", "Bash(tsc:*)");
-  }
-  if (stack.languages.includes("python")) {
-    permissions.push(
-      "Bash(python:*)",
-      "Bash(pip:*)",
-      "Bash(poetry:*)",
-      "Bash(pytest:*)",
-      "Bash(uvicorn:*)"
-    );
-  }
-  if (stack.languages.includes("go")) {
-    permissions.push("Bash(go:*)");
-  }
-  if (stack.languages.includes("rust")) {
-    permissions.push("Bash(cargo:*)", "Bash(rustc:*)");
-  }
-  if (stack.languages.includes("ruby")) {
-    permissions.push("Bash(ruby:*)", "Bash(bundle:*)", "Bash(rails:*)", "Bash(rake:*)");
-  }
-  if (stack.testingFramework) {
-    const testCommands = {
-      jest: ["jest:*"],
-      vitest: ["vitest:*"],
-      playwright: ["playwright:*"],
-      cypress: ["cypress:*"],
-      pytest: ["pytest:*"],
-      rspec: ["rspec:*"]
-    };
-    const cmds = testCommands[stack.testingFramework];
-    if (cmds) {
-      permissions.push(...cmds.map((c) => `Bash(${c})`));
-    }
-  }
-  if (stack.linter) {
-    permissions.push(`Bash(${stack.linter}:*)`);
-  }
-  if (stack.formatter) {
-    permissions.push(`Bash(${stack.formatter}:*)`);
-  }
-  permissions.push(
-    "Bash(ls:*)",
-    "Bash(mkdir:*)",
-    "Bash(cat:*)",
-    "Bash(echo:*)",
-    "Bash(grep:*)",
-    "Bash(find:*)"
-  );
-  if (stack.hasDocker) {
-    permissions.push("Bash(docker:*)", "Bash(docker-compose:*)");
-  }
-  const settings = {
-    $schema: "https://json.schemastore.org/claude-code-settings.json",
-    permissions: {
-      allow: [...new Set(permissions)]
-      // Deduplicate
-    }
-  };
-  return {
-    type: "settings",
-    path: ".claude/settings.json",
-    content: JSON.stringify(settings, null, 2),
-    isNew: true
-  };
-}
-function generateSkills(stack) {
-  const artifacts = [];
-  artifacts.push(generatePatternDiscoverySkill());
-  artifacts.push(generateSystematicDebuggingSkill());
-  artifacts.push(generateTestingMethodologySkill(stack));
-  artifacts.push(generateIterativeDevelopmentSkill(stack));
-  artifacts.push(generateCommitHygieneSkill());
-  artifacts.push(generateCodeDeduplicationSkill());
-  artifacts.push(generateSimplicityRulesSkill());
-  artifacts.push(generateSecuritySkill(stack));
-  if (stack.frameworks.includes("nextjs")) {
-    artifacts.push(generateNextJsSkill());
-  }
-  if (stack.frameworks.includes("react") && !stack.frameworks.includes("nextjs")) {
-    artifacts.push(generateReactSkill());
-  }
-  if (stack.frameworks.includes("fastapi")) {
-    artifacts.push(generateFastAPISkill());
-  }
-  if (stack.frameworks.includes("nestjs")) {
-    artifacts.push(generateNestJSSkill());
-  }
-  if (stack.frameworks.includes("swiftui")) {
-    artifacts.push(generateSwiftUISkill());
-  }
-  if (stack.frameworks.includes("uikit")) {
-    artifacts.push(generateUIKitSkill());
-  }
-  if (stack.frameworks.includes("vapor")) {
-    artifacts.push(generateVaporSkill());
-  }
-  if (stack.frameworks.includes("jetpack-compose")) {
-    artifacts.push(generateJetpackComposeSkill());
-  }
-  if (stack.frameworks.includes("android-views")) {
-    artifacts.push(generateAndroidViewsSkill());
-  }
-  return artifacts;
-}
-function generatePatternDiscoverySkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/pattern-discovery.md",
-    content: `---
-name: pattern-discovery
-description: Analyze existing codebase to discover and document patterns
-globs:
-  - "src/**/*"
-  - "lib/**/*"
-  - "app/**/*"
-  - "components/**/*"
-  - "pages/**/*"
-  - "api/**/*"
-  - "services/**/*"
----
-
-# Pattern Discovery
-
-When starting work on a project, analyze the existing code to understand its patterns.
-
-## Discovery Process
-
-### 1. Check for Existing Documentation
-
-\`\`\`
-Look for:
-- README.md, CONTRIBUTING.md
-- docs/ folder
-- Code comments and JSDoc/TSDoc
-- .editorconfig, .prettierrc, eslint config
-\`\`\`
-
-### 2. Analyze Project Structure
-
-\`\`\`
-Questions to answer:
-- How are files organized? (by feature, by type, flat?)
-- Where does business logic live?
-- Where are tests located?
-- How are configs managed?
-\`\`\`
-
-### 3. Detect Code Patterns
-
-\`\`\`
-Look at 3-5 similar files to find:
-- Naming conventions (camelCase, snake_case, PascalCase)
-- Import organization (grouped? sorted? relative vs absolute?)
-- Export style (named, default, barrel files?)
-- Error handling approach
-- Logging patterns
-\`\`\`
-
-### 4. Identify Architecture
-
-\`\`\`
-Common patterns to detect:
-- MVC / MVVM / Clean Architecture
-- Repository pattern
-- Service layer
-- Dependency injection
-- Event-driven
-- Functional vs OOP
-\`\`\`
-
-## When No Code Exists
-
-If starting a new project:
-
-1. Ask about preferred patterns
-2. Check package.json/config files for framework hints
-3. Use sensible defaults for detected stack
-4. Document decisions in \`.claude/state/task.md\`
-
-## Important
-
-- **Match existing patterns** - don't impose new ones
-- **When in doubt, check similar files** in the codebase
-- **Document as you discover** - note patterns in task state
-- **Ask if unclear** - better to ask than assume
-`,
-    isNew: true
-  };
-}
-function generateSystematicDebuggingSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/systematic-debugging.md",
-    content: `---
-name: systematic-debugging
-description: Methodical approach to finding and fixing bugs
-globs:
-  - "**/*.ts"
-  - "**/*.tsx"
-  - "**/*.js"
-  - "**/*.jsx"
-  - "**/*.py"
-  - "**/*.go"
-  - "**/*.rs"
----
-
-# Systematic Debugging
-
-A 4-phase methodology for finding and fixing bugs efficiently.
-
-## Phase 1: Reproduce
-
-Before fixing, confirm you can reproduce the bug.
-
-\`\`\`
-1. Get exact steps to reproduce
-2. Identify expected vs actual behavior
-3. Note any error messages verbatim
-4. Check if it's consistent or intermittent
-\`\`\`
-
-## Phase 2: Locate
-
-Narrow down where the bug occurs.
-
-\`\`\`
-Techniques:
-- Binary search through code flow
-- Add logging at key points
-- Check recent changes (git log, git diff)
-- Review stack traces carefully
-- Use debugger breakpoints
-\`\`\`
-
-## Phase 3: Diagnose
-
-Understand WHY the bug happens.
-
-\`\`\`
-Questions:
-- What assumptions are being violated?
-- What state is unexpected?
-- Is this a logic error, data error, or timing issue?
-- Are there edge cases not handled?
-\`\`\`
-
-## Phase 4: Fix
-
-Apply the minimal correct fix.
-
-\`\`\`
-Guidelines:
-- Fix the root cause, not symptoms
-- Make the smallest change that fixes the issue
-- Add a test that would have caught this bug
-- Check for similar bugs elsewhere
-- Update documentation if needed
-\`\`\`
-
-## Quick Reference
-
-| Symptom | Check First |
-|---------|-------------|
-| TypeError | Null/undefined values, type mismatches |
-| Off-by-one | Loop bounds, array indices |
-| Race condition | Async operations, shared state |
-| Memory leak | Event listeners, subscriptions, closures |
-| Infinite loop | Exit conditions, recursive calls |
-`,
-    isNew: true
-  };
-}
-function generateTestingMethodologySkill(stack) {
-  const testingFramework = stack.testingFramework || "generic";
-  const examples = getTestingExamples(stack);
-  return {
-    type: "skill",
-    path: ".claude/skills/testing-methodology.md",
-    content: `---
-name: testing-methodology
-description: Testing patterns and best practices for this project
-globs:
-  - "**/*.test.*"
-  - "**/*.spec.*"
-  - "**/test/**"
-  - "**/tests/**"
-  - "**/__tests__/**"
----
-
-# Testing Methodology
-
-## Testing Framework
-
-This project uses: **${testingFramework}**
-
-## The AAA Pattern
-
-Structure every test with:
-
-\`\`\`
-Arrange - Set up test data and conditions
-Act     - Execute the code being tested
-Assert  - Verify the expected outcome
-\`\`\`
-
-## What to Test
-
-### Must Test
-- Core business logic
-- Edge cases and boundaries
-- Error handling paths
-- Public API contracts
-
-### Consider Testing
-- Integration points
-- Complex conditional logic
-- State transitions
-
-### Skip Testing
-- Framework internals
-- Simple getters/setters
-- Configuration constants
-
-## Example Patterns
-
-${examples}
-
-## Test Naming
-
-\`\`\`
-Format: [unit]_[scenario]_[expected result]
-
-Examples:
-- calculateTotal_withEmptyCart_returnsZero
-- userService_createUser_savesToDatabase
-- parseDate_invalidFormat_throwsError
-\`\`\`
-
-## Mocking Guidelines
-
-1. **Mock external dependencies** - APIs, databases, file system
-2. **Don't mock what you own** - Prefer real implementations for your code
-3. **Keep mocks simple** - Complex mocks often indicate design issues
-4. **Reset mocks between tests** - Avoid state leakage
-
-## Coverage Philosophy
-
-- Aim for **80%+ coverage** on critical paths
-- Don't chase 100% - it often leads to brittle tests
-- Focus on **behavior coverage**, not line coverage
-`,
-    isNew: true
-  };
-}
-function getTestingExamples(stack) {
-  if (stack.testingFramework === "vitest" || stack.testingFramework === "jest") {
-    return `
-\`\`\`typescript
-import { describe, it, expect } from '${stack.testingFramework}';
-
-describe('UserService', () => {
-  it('should create user with valid data', async () => {
-    // Arrange
-    const userData = { name: 'Test', email: 'test@example.com' };
-
-    // Act
-    const user = await userService.create(userData);
-
-    // Assert
-    expect(user.id).toBeDefined();
-    expect(user.name).toBe('Test');
-  });
-
-  it('should throw on invalid email', async () => {
-    // Arrange
-    const userData = { name: 'Test', email: 'invalid' };
-
-    // Act & Assert
-    await expect(userService.create(userData)).rejects.toThrow('Invalid email');
-  });
-});
-\`\`\``;
-  }
-  if (stack.testingFramework === "pytest") {
-    return `
-\`\`\`python
-import pytest
-from myapp.services import UserService
-
-class TestUserService:
-    def test_create_user_with_valid_data(self, db_session):
-        # Arrange
-        user_data = {"name": "Test", "email": "test@example.com"}
-        service = UserService(db_session)
-
-        # Act
-        user = service.create(user_data)
-
-        # Assert
-        assert user.id is not None
-        assert user.name == "Test"
-
-    def test_create_user_invalid_email_raises(self, db_session):
-        # Arrange
-        user_data = {"name": "Test", "email": "invalid"}
-        service = UserService(db_session)
-
-        # Act & Assert
-        with pytest.raises(ValueError, match="Invalid email"):
-            service.create(user_data)
-\`\`\``;
-  }
-  if (stack.testingFramework === "go-test") {
-    return `
-\`\`\`go
-func TestUserService_Create(t *testing.T) {
-    t.Run("creates user with valid data", func(t *testing.T) {
-        // Arrange
-        svc := NewUserService(mockDB)
-        userData := UserInput{Name: "Test", Email: "test@example.com"}
-
-        // Act
-        user, err := svc.Create(userData)
-
-        // Assert
-        assert.NoError(t, err)
-        assert.NotEmpty(t, user.ID)
-        assert.Equal(t, "Test", user.Name)
-    })
-
-    t.Run("returns error on invalid email", func(t *testing.T) {
-        // Arrange
-        svc := NewUserService(mockDB)
-        userData := UserInput{Name: "Test", Email: "invalid"}
-
-        // Act
-        _, err := svc.Create(userData)
-
-        // Assert
-        assert.ErrorContains(t, err, "invalid email")
-    })
-}
-\`\`\``;
-  }
-  return `
-\`\`\`
-// Add examples for your testing framework here
-describe('Component', () => {
-  it('should behave correctly', () => {
-    // Arrange - set up test conditions
-    // Act - execute the code
-    // Assert - verify results
-  });
-});
-\`\`\``;
-}
-function generateNextJsSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/nextjs-patterns.md",
-    content: `---
-name: nextjs-patterns
-description: Next.js App Router patterns and best practices
-globs:
-  - "app/**/*"
-  - "src/app/**/*"
-  - "components/**/*"
----
-
-# Next.js Patterns (App Router)
-
-## File Conventions
-
-| File | Purpose |
-|------|---------|
-| \`page.tsx\` | Route UI |
-| \`layout.tsx\` | Shared layout wrapper |
-| \`loading.tsx\` | Loading UI (Suspense) |
-| \`error.tsx\` | Error boundary |
-| \`not-found.tsx\` | 404 page |
-| \`route.ts\` | API endpoint |
-
-## Server vs Client Components
-
-\`\`\`tsx
-// Server Component (default) - runs on server only
-export default function ServerComponent() {
-  // Can use: async/await, direct DB access, server-only code
-  // Cannot use: useState, useEffect, browser APIs
-  return <div>Server rendered</div>;
-}
-
-// Client Component - runs on client
-'use client';
-export default function ClientComponent() {
-  // Can use: hooks, event handlers, browser APIs
-  const [state, setState] = useState();
-  return <button onClick={() => setState(...)}>Click</button>;
-}
-\`\`\`
-
-## Data Fetching
-
-\`\`\`tsx
-// Server Component - fetch directly
-async function ProductPage({ params }: { params: { id: string } }) {
-  const product = await db.product.findUnique({ where: { id: params.id } });
-  return <ProductDetails product={product} />;
-}
-
-// With caching
-const getData = cache(async (id: string) => {
-  return await db.find(id);
-});
-\`\`\`
-
-## Server Actions
-
-\`\`\`tsx
-// actions.ts
-'use server';
-
-export async function createPost(formData: FormData) {
-  const title = formData.get('title');
-  await db.post.create({ data: { title } });
-  revalidatePath('/posts');
-}
-
-// In component
-<form action={createPost}>
-  <input name="title" />
-  <button type="submit">Create</button>
-</form>
-\`\`\`
-
-## Route Handlers
-
-\`\`\`tsx
-// app/api/users/route.ts
-import { NextResponse } from 'next/server';
-
-export async function GET() {
-  const users = await db.user.findMany();
-  return NextResponse.json(users);
-}
-
-export async function POST(request: Request) {
-  const body = await request.json();
-  const user = await db.user.create({ data: body });
-  return NextResponse.json(user, { status: 201 });
-}
-\`\`\`
-
-## Patterns to Follow
-
-1. **Default to Server Components** - Only use 'use client' when needed
-2. **Colocate related files** - Keep components near their routes
-3. **Use route groups** - \`(auth)/login\` for organization without URL impact
-4. **Parallel routes** - \`@modal/\` for simultaneous rendering
-5. **Intercepting routes** - \`(.)/photo\` for modal patterns
-`,
-    isNew: true
-  };
-}
-function generateReactSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/react-components.md",
-    content: `---
-name: react-components
-description: React component patterns and best practices
-globs:
-  - "src/components/**/*"
-  - "components/**/*"
-  - "**/*.tsx"
-  - "**/*.jsx"
----
-
-# React Component Patterns
-
-## Component Structure
-
-\`\`\`tsx
-// Standard component structure
-import { useState, useCallback } from 'react';
-import type { ComponentProps } from './types';
-
-interface Props {
-  title: string;
-  onAction?: () => void;
-  children?: React.ReactNode;
-}
-
-export function MyComponent({ title, onAction, children }: Props) {
-  const [state, setState] = useState(false);
-
-  const handleClick = useCallback(() => {
-    setState(true);
-    onAction?.();
-  }, [onAction]);
-
-  return (
-    <div>
-      <h1>{title}</h1>
-      <button onClick={handleClick}>Action</button>
-      {children}
-    </div>
-  );
-}
-\`\`\`
-
-## Hooks Patterns
-
-\`\`\`tsx
-// Custom hook for data fetching
-function useUser(id: string) {
-  const [user, setUser] = useState<User | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-
-  useEffect(() => {
-    fetchUser(id)
-      .then(setUser)
-      .catch(setError)
-      .finally(() => setLoading(false));
-  }, [id]);
-
-  return { user, loading, error };
-}
-\`\`\`
-
-## State Management
-
-\`\`\`tsx
-// Use reducer for complex state
-const [state, dispatch] = useReducer(reducer, initialState);
-
-// Use context for shared state
-const ThemeContext = createContext<Theme>('light');
-export const useTheme = () => useContext(ThemeContext);
-\`\`\`
-
-## Performance
-
-1. **Memoize expensive calculations**: \`useMemo\`
-2. **Memoize callbacks**: \`useCallback\`
-3. **Memoize components**: \`React.memo\`
-4. **Avoid inline objects/arrays in props**
-
-## Testing
-
-\`\`\`tsx
-import { render, screen, fireEvent } from '@testing-library/react';
-
-test('button triggers action', () => {
-  const onAction = vi.fn();
-  render(<MyComponent title="Test" onAction={onAction} />);
-
-  fireEvent.click(screen.getByRole('button'));
-
-  expect(onAction).toHaveBeenCalled();
-});
-\`\`\`
-`,
-    isNew: true
-  };
-}
-function generateFastAPISkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/fastapi-patterns.md",
-    content: `---
-name: fastapi-patterns
-description: FastAPI endpoint patterns and best practices
-globs:
-  - "app/**/*.py"
-  - "src/**/*.py"
-  - "api/**/*.py"
-  - "routers/**/*.py"
----
-
-# FastAPI Patterns
-
-## Router Structure
-
-\`\`\`python
-# routers/users.py
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
-
-from app.database import get_db
-from app.schemas import UserCreate, UserResponse
-from app.services import UserService
-
-router = APIRouter(prefix="/users", tags=["users"])
-
-@router.get("/", response_model=list[UserResponse])
-async def list_users(
-    skip: int = 0,
-    limit: int = 100,
-    db: Session = Depends(get_db)
-):
-    service = UserService(db)
-    return service.get_all(skip=skip, limit=limit)
-
-@router.post("/", response_model=UserResponse, status_code=201)
-async def create_user(
-    user: UserCreate,
-    db: Session = Depends(get_db)
-):
-    service = UserService(db)
-    return service.create(user)
-\`\`\`
-
-## Dependency Injection
-
-\`\`\`python
-# Dependencies
-def get_current_user(token: str = Depends(oauth2_scheme)) -> User:
-    user = decode_token(token)
-    if not user:
-        raise HTTPException(status_code=401, detail="Invalid token")
-    return user
-
-def require_admin(user: User = Depends(get_current_user)) -> User:
-    if not user.is_admin:
-        raise HTTPException(status_code=403, detail="Admin required")
-    return user
-
-# Usage
-@router.delete("/{id}")
-async def delete_user(id: int, admin: User = Depends(require_admin)):
-    ...
-\`\`\`
-
-## Pydantic Schemas
-
-\`\`\`python
-from pydantic import BaseModel, EmailStr, Field
-
-class UserBase(BaseModel):
-    email: EmailStr
-    name: str = Field(..., min_length=1, max_length=100)
-
-class UserCreate(UserBase):
-    password: str = Field(..., min_length=8)
-
-class UserResponse(UserBase):
-    id: int
-    created_at: datetime
-
-    class Config:
-        from_attributes = True  # For ORM mode
-\`\`\`
-
-## Error Handling
-
-\`\`\`python
-from fastapi import HTTPException
-from fastapi.responses import JSONResponse
-
-# Custom exception
-class NotFoundError(Exception):
-    def __init__(self, resource: str, id: int):
-        self.resource = resource
-        self.id = id
-
-# Exception handler
-@app.exception_handler(NotFoundError)
-async def not_found_handler(request, exc: NotFoundError):
-    return JSONResponse(
-        status_code=404,
-        content={"error": f"{exc.resource} {exc.id} not found"}
-    )
-\`\`\`
-
-## Testing
-
-\`\`\`python
-from fastapi.testclient import TestClient
-
-def test_create_user(client: TestClient):
-    response = client.post("/users/", json={
-        "email": "test@example.com",
-        "name": "Test",
-        "password": "password123"
-    })
-    assert response.status_code == 201
-    assert response.json()["email"] == "test@example.com"
-\`\`\`
-`,
-    isNew: true
-  };
-}
-function generateNestJSSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/nestjs-patterns.md",
-    content: `---
-name: nestjs-patterns
-description: NestJS module patterns and best practices
-globs:
-  - "src/**/*.ts"
-  - "**/*.module.ts"
-  - "**/*.controller.ts"
-  - "**/*.service.ts"
----
-
-# NestJS Patterns
-
-## Module Structure
-
-\`\`\`typescript
-// users/users.module.ts
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { UsersController } from './users.controller';
-import { UsersService } from './users.service';
-import { User } from './entities/user.entity';
-
-@Module({
-  imports: [TypeOrmModule.forFeature([User])],
-  controllers: [UsersController],
-  providers: [UsersService],
-  exports: [UsersService],
-})
-export class UsersModule {}
-\`\`\`
-
-## Controller Pattern
-
-\`\`\`typescript
-// users/users.controller.ts
-import { Controller, Get, Post, Body, Param, UseGuards } from '@nestjs/common';
-import { UsersService } from './users.service';
-import { CreateUserDto } from './dto/create-user.dto';
-import { JwtAuthGuard } from '../auth/jwt-auth.guard';
-
-@Controller('users')
-export class UsersController {
-  constructor(private readonly usersService: UsersService) {}
-
-  @Get()
-  findAll() {
-    return this.usersService.findAll();
-  }
-
-  @Get(':id')
-  findOne(@Param('id') id: string) {
-    return this.usersService.findOne(+id);
-  }
-
-  @Post()
-  @UseGuards(JwtAuthGuard)
-  create(@Body() createUserDto: CreateUserDto) {
-    return this.usersService.create(createUserDto);
-  }
-}
-\`\`\`
-
-## Service Pattern
-
-\`\`\`typescript
-// users/users.service.ts
-import { Injectable, NotFoundException } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { User } from './entities/user.entity';
-
-@Injectable()
-export class UsersService {
-  constructor(
-    @InjectRepository(User)
-    private usersRepository: Repository<User>,
-  ) {}
-
-  findAll(): Promise<User[]> {
-    return this.usersRepository.find();
-  }
-
-  async findOne(id: number): Promise<User> {
-    const user = await this.usersRepository.findOne({ where: { id } });
-    if (!user) {
-      throw new NotFoundException(\`User #\${id} not found\`);
-    }
-    return user;
-  }
-}
-\`\`\`
-
-## DTO Validation
-
-\`\`\`typescript
-// dto/create-user.dto.ts
-import { IsEmail, IsString, MinLength } from 'class-validator';
-
-export class CreateUserDto {
-  @IsEmail()
-  email: string;
-
-  @IsString()
-  @MinLength(1)
-  name: string;
-
-  @IsString()
-  @MinLength(8)
-  password: string;
-}
-\`\`\`
-
-## Testing
-
-\`\`\`typescript
-describe('UsersService', () => {
-  let service: UsersService;
-  let repository: MockType<Repository<User>>;
-
-  beforeEach(async () => {
-    const module = await Test.createTestingModule({
-      providers: [
-        UsersService,
-        { provide: getRepositoryToken(User), useFactory: repositoryMockFactory },
-      ],
-    }).compile();
-
-    service = module.get(UsersService);
-    repository = module.get(getRepositoryToken(User));
-  });
-
-  it('should find all users', async () => {
-    const users = [{ id: 1, name: 'Test' }];
-    repository.find.mockReturnValue(users);
-
-    expect(await service.findAll()).toEqual(users);
-  });
-});
-\`\`\`
-`,
-    isNew: true
-  };
-}
-function generateSwiftUISkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/swiftui-patterns.md",
-    content: `---
-name: swiftui-patterns
-description: SwiftUI declarative UI patterns and best practices
-globs:
-  - "**/*.swift"
----
-
-# SwiftUI Patterns
-
-## View Structure
-
-\`\`\`swift
-import SwiftUI
-
-struct ContentView: View {
-    @State private var count = 0
-    @StateObject private var viewModel = ContentViewModel()
-
-    var body: some View {
-        VStack(spacing: 16) {
-            Text("Count: \\(count)")
-                .font(.title)
-
-            Button("Increment") {
-                count += 1
-            }
-            .buttonStyle(.borderedProminent)
-        }
-        .padding()
-    }
-}
-
-#Preview {
-    ContentView()
-}
-\`\`\`
-
-## Property Wrappers
-
-| Wrapper | Use Case |
-|---------|----------|
-| \`@State\` | Simple value types owned by view |
-| \`@Binding\` | Two-way connection to parent's state |
-| \`@StateObject\` | Reference type owned by view (create once) |
-| \`@ObservedObject\` | Reference type passed from parent |
-| \`@EnvironmentObject\` | Shared data through view hierarchy |
-| \`@Environment\` | System environment values |
-
-## MVVM Pattern
-
-\`\`\`swift
-// ViewModel
-@MainActor
-class UserViewModel: ObservableObject {
-    @Published var users: [User] = []
-    @Published var isLoading = false
-    @Published var error: Error?
-
-    private let service: UserService
-
-    init(service: UserService = .shared) {
-        self.service = service
-    }
-
-    func fetchUsers() async {
-        isLoading = true
-        defer { isLoading = false }
-
-        do {
-            users = try await service.getUsers()
-        } catch {
-            self.error = error
-        }
-    }
-}
-
-// View
-struct UsersView: View {
-    @StateObject private var viewModel = UserViewModel()
-
-    var body: some View {
-        List(viewModel.users) { user in
-            UserRow(user: user)
-        }
-        .overlay {
-            if viewModel.isLoading {
-                ProgressView()
-            }
-        }
-        .task {
-            await viewModel.fetchUsers()
-        }
-    }
-}
-\`\`\`
-
-## Navigation (iOS 16+)
-
-\`\`\`swift
-struct AppNavigation: View {
-    @State private var path = NavigationPath()
-
-    var body: some View {
-        NavigationStack(path: $path) {
-            HomeView()
-                .navigationDestination(for: User.self) { user in
-                    UserDetailView(user: user)
-                }
-                .navigationDestination(for: Settings.self) { settings in
-                    SettingsView(settings: settings)
-                }
-        }
-    }
-}
-\`\`\`
-
-## Async/Await Patterns
-
-\`\`\`swift
-// Task modifier for view lifecycle
-.task {
-    await loadData()
-}
-
-// Task with cancellation
-.task(id: searchText) {
-    try? await Task.sleep(for: .milliseconds(300))
-    await search(searchText)
-}
-
-// Refreshable
-.refreshable {
-    await viewModel.refresh()
-}
-\`\`\`
-
-## Best Practices
-
-1. **Keep views small** - Extract subviews for reusability
-2. **Use \`@MainActor\`** - For ViewModels updating UI
-3. **Prefer value types** - Structs over classes when possible
-4. **Use \`.task\`** - Instead of \`.onAppear\` for async work
-5. **Preview extensively** - Use #Preview for rapid iteration
-`,
-    isNew: true
-  };
-}
-function generateUIKitSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/uikit-patterns.md",
-    content: `---
-name: uikit-patterns
-description: UIKit view controller patterns and best practices
-globs:
-  - "**/*.swift"
----
-
-# UIKit Patterns
-
-## View Controller Structure
-
-\`\`\`swift
-import UIKit
-
-class UserViewController: UIViewController {
-    // MARK: - Properties
-    private let viewModel: UserViewModel
-    private var cancellables = Set<AnyCancellable>()
-
-    // MARK: - UI Components
-    private lazy var tableView: UITableView = {
-        let table = UITableView()
-        table.translatesAutoresizingMaskIntoConstraints = false
-        table.delegate = self
-        table.dataSource = self
-        table.register(UserCell.self, forCellReuseIdentifier: UserCell.identifier)
-        return table
-    }()
-
-    // MARK: - Lifecycle
-    init(viewModel: UserViewModel) {
-        self.viewModel = viewModel
-        super.init(nibName: nil, bundle: nil)
-    }
-
-    required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
-
-    override func viewDidLoad() {
-        super.viewDidLoad()
-        setupUI()
-        setupBindings()
-        viewModel.fetchUsers()
-    }
-
-    // MARK: - Setup
-    private func setupUI() {
-        view.backgroundColor = .systemBackground
-        view.addSubview(tableView)
-
-        NSLayoutConstraint.activate([
-            tableView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
-            tableView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
-            tableView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
-            tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
-        ])
-    }
-
-    private func setupBindings() {
-        viewModel.$users
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] _ in
-                self?.tableView.reloadData()
-            }
-            .store(in: &cancellables)
-    }
-}
-\`\`\`
-
-## Coordinator Pattern
-
-\`\`\`swift
-protocol Coordinator: AnyObject {
-    var childCoordinators: [Coordinator] { get set }
-    var navigationController: UINavigationController { get set }
-    func start()
-}
-
-class AppCoordinator: Coordinator {
-    var childCoordinators: [Coordinator] = []
-    var navigationController: UINavigationController
-
-    init(navigationController: UINavigationController) {
-        self.navigationController = navigationController
-    }
-
-    func start() {
-        let vc = HomeViewController()
-        vc.coordinator = self
-        navigationController.pushViewController(vc, animated: false)
-    }
-
-    func showUserDetail(_ user: User) {
-        let vc = UserDetailViewController(user: user)
-        navigationController.pushViewController(vc, animated: true)
-    }
-}
-\`\`\`
-
-## Table View Cell
-
-\`\`\`swift
-class UserCell: UITableViewCell {
-    static let identifier = "UserCell"
-
-    private let nameLabel: UILabel = {
-        let label = UILabel()
-        label.font = .preferredFont(forTextStyle: .headline)
-        label.translatesAutoresizingMaskIntoConstraints = false
-        return label
-    }()
-
-    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
-        super.init(style: style, reuseIdentifier: reuseIdentifier)
-        setupUI()
-    }
-
-    required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
-
-    private func setupUI() {
-        contentView.addSubview(nameLabel)
-        NSLayoutConstraint.activate([
-            nameLabel.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 16),
-            nameLabel.centerYAnchor.constraint(equalTo: contentView.centerYAnchor)
-        ])
-    }
-
-    func configure(with user: User) {
-        nameLabel.text = user.name
-    }
-}
-\`\`\`
-
-## Best Practices
-
-1. **Use Auto Layout** - Programmatic constraints over Storyboards
-2. **MARK comments** - Organize code sections
-3. **Coordinator pattern** - For navigation logic
-4. **Dependency injection** - Pass dependencies via init
-5. **Combine for bindings** - Reactive updates from ViewModel
-`,
-    isNew: true
-  };
-}
-function generateVaporSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/vapor-patterns.md",
-    content: `---
-name: vapor-patterns
-description: Vapor server-side Swift patterns
-globs:
-  - "**/*.swift"
-  - "Package.swift"
----
-
-# Vapor Patterns
-
-## Route Structure
-
-\`\`\`swift
-import Vapor
-
-func routes(_ app: Application) throws {
-    // Basic routes
-    app.get { req in
-        "Hello, world!"
-    }
-
-    // Route groups
-    let api = app.grouped("api", "v1")
-
-    // Controller registration
-    try api.register(collection: UserController())
-}
-\`\`\`
-
-## Controller Pattern
-
-\`\`\`swift
-import Vapor
-
-struct UserController: RouteCollection {
-    func boot(routes: RoutesBuilder) throws {
-        let users = routes.grouped("users")
-
-        users.get(use: index)
-        users.post(use: create)
-        users.group(":userID") { user in
-            user.get(use: show)
-            user.put(use: update)
-            user.delete(use: delete)
-        }
-    }
-
-    // GET /users
-    func index(req: Request) async throws -> [UserDTO] {
-        try await User.query(on: req.db).all().map { $0.toDTO() }
-    }
-
-    // POST /users
-    func create(req: Request) async throws -> UserDTO {
-        let input = try req.content.decode(CreateUserInput.self)
-        let user = User(name: input.name, email: input.email)
-        try await user.save(on: req.db)
-        return user.toDTO()
-    }
-
-    // GET /users/:userID
-    func show(req: Request) async throws -> UserDTO {
-        guard let user = try await User.find(req.parameters.get("userID"), on: req.db) else {
-            throw Abort(.notFound)
-        }
-        return user.toDTO()
-    }
-}
-\`\`\`
-
-## Fluent Models
-
-\`\`\`swift
-import Fluent
-import Vapor
-
-final class User: Model, Content {
-    static let schema = "users"
-
-    @ID(key: .id)
-    var id: UUID?
-
-    @Field(key: "name")
-    var name: String
-
-    @Field(key: "email")
-    var email: String
-
-    @Timestamp(key: "created_at", on: .create)
-    var createdAt: Date?
-
-    @Children(for: \\.$user)
-    var posts: [Post]
-
-    init() {}
-
-    init(id: UUID? = nil, name: String, email: String) {
-        self.id = id
-        self.name = name
-        self.email = email
-    }
-}
-
-// Migration
-struct CreateUser: AsyncMigration {
-    func prepare(on database: Database) async throws {
-        try await database.schema("users")
-            .id()
-            .field("name", .string, .required)
-            .field("email", .string, .required)
-            .field("created_at", .datetime)
-            .unique(on: "email")
-            .create()
-    }
-
-    func revert(on database: Database) async throws {
-        try await database.schema("users").delete()
-    }
-}
-\`\`\`
-
-## DTOs and Validation
-
-\`\`\`swift
-struct CreateUserInput: Content, Validatable {
-    var name: String
-    var email: String
-
-    static func validations(_ validations: inout Validations) {
-        validations.add("name", as: String.self, is: !.empty)
-        validations.add("email", as: String.self, is: .email)
-    }
-}
-
-struct UserDTO: Content {
-    var id: UUID?
-    var name: String
-    var email: String
-}
-
-extension User {
-    func toDTO() -> UserDTO {
-        UserDTO(id: id, name: name, email: email)
-    }
-}
-\`\`\`
-
-## Middleware
-
-\`\`\`swift
-struct AuthMiddleware: AsyncMiddleware {
-    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
-        guard let token = request.headers.bearerAuthorization?.token else {
-            throw Abort(.unauthorized)
-        }
-
-        // Validate token
-        let user = try await validateToken(token, on: request)
-        request.auth.login(user)
-
-        return try await next.respond(to: request)
-    }
-}
-\`\`\`
-
-## Testing
-
-\`\`\`swift
-@testable import App
-import XCTVapor
-
-final class UserTests: XCTestCase {
-    var app: Application!
-
-    override func setUp() async throws {
-        app = Application(.testing)
-        try configure(app)
-        try await app.autoMigrate()
-    }
-
-    override func tearDown() async throws {
-        try await app.autoRevert()
-        app.shutdown()
-    }
-
-    func testCreateUser() async throws {
-        try app.test(.POST, "api/v1/users", beforeRequest: { req in
-            try req.content.encode(CreateUserInput(name: "Test", email: "test@example.com"))
-        }, afterResponse: { res in
-            XCTAssertEqual(res.status, .ok)
-            let user = try res.content.decode(UserDTO.self)
-            XCTAssertEqual(user.name, "Test")
-        })
-    }
-}
-\`\`\`
-`,
-    isNew: true
-  };
-}
-function generateJetpackComposeSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/compose-patterns.md",
-    content: `---
-name: compose-patterns
-description: Jetpack Compose UI patterns and best practices
-globs:
-  - "**/*.kt"
----
-
-# Jetpack Compose Patterns
-
-## Composable Structure
-
-\`\`\`kotlin
-@Composable
-fun UserScreen(
-    viewModel: UserViewModel = hiltViewModel()
-) {
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-
-    UserScreenContent(
-        uiState = uiState,
-        onRefresh = viewModel::refresh,
-        onUserClick = viewModel::selectUser
-    )
-}
-
-@Composable
-private fun UserScreenContent(
-    uiState: UserUiState,
-    onRefresh: () -> Unit,
-    onUserClick: (User) -> Unit
-) {
-    Scaffold(
-        topBar = {
-            TopAppBar(title = { Text("Users") })
-        }
-    ) { padding ->
-        when (uiState) {
-            is UserUiState.Loading -> LoadingIndicator()
-            is UserUiState.Success -> UserList(
-                users = uiState.users,
-                onUserClick = onUserClick,
-                modifier = Modifier.padding(padding)
-            )
-            is UserUiState.Error -> ErrorMessage(uiState.message)
-        }
-    }
-}
-\`\`\`
-
-## State Management
-
-\`\`\`kotlin
-// UI State
-sealed interface UserUiState {
-    object Loading : UserUiState
-    data class Success(val users: List<User>) : UserUiState
-    data class Error(val message: String) : UserUiState
-}
-
-// ViewModel
-@HiltViewModel
-class UserViewModel @Inject constructor(
-    private val repository: UserRepository
-) : ViewModel() {
-
-    private val _uiState = MutableStateFlow<UserUiState>(UserUiState.Loading)
-    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
-
-    init {
-        loadUsers()
-    }
-
-    fun refresh() {
-        loadUsers()
-    }
-
-    private fun loadUsers() {
-        viewModelScope.launch {
-            _uiState.value = UserUiState.Loading
-            repository.getUsers()
-                .onSuccess { users ->
-                    _uiState.value = UserUiState.Success(users)
-                }
-                .onFailure { error ->
-                    _uiState.value = UserUiState.Error(error.message ?: "Unknown error")
-                }
-        }
-    }
-}
-\`\`\`
-
-## Reusable Components
-
-\`\`\`kotlin
-@Composable
-fun UserCard(
-    user: User,
-    onClick: () -> Unit,
-    modifier: Modifier = Modifier
-) {
-    Card(
-        onClick = onClick,
-        modifier = modifier.fillMaxWidth()
-    ) {
-        Row(
-            modifier = Modifier.padding(16.dp),
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            AsyncImage(
-                model = user.avatarUrl,
-                contentDescription = null,
-                modifier = Modifier
-                    .size(48.dp)
-                    .clip(CircleShape)
-            )
-            Spacer(modifier = Modifier.width(16.dp))
-            Column {
-                Text(
-                    text = user.name,
-                    style = MaterialTheme.typography.titleMedium
-                )
-                Text(
-                    text = user.email,
-                    style = MaterialTheme.typography.bodySmall
-                )
-            }
-        }
-    }
-}
-\`\`\`
-
-## Navigation
-
-\`\`\`kotlin
-@Composable
-fun AppNavigation() {
-    val navController = rememberNavController()
-
-    NavHost(
-        navController = navController,
-        startDestination = "home"
-    ) {
-        composable("home") {
-            HomeScreen(
-                onUserClick = { userId ->
-                    navController.navigate("user/$userId")
-                }
-            )
-        }
-        composable(
-            route = "user/{userId}",
-            arguments = listOf(navArgument("userId") { type = NavType.StringType })
-        ) { backStackEntry ->
-            val userId = backStackEntry.arguments?.getString("userId")
-            UserDetailScreen(userId = userId)
-        }
-    }
-}
-\`\`\`
-
-## Theming
-
-\`\`\`kotlin
-@Composable
-fun AppTheme(
-    darkTheme: Boolean = isSystemInDarkTheme(),
-    content: @Composable () -> Unit
-) {
-    val colorScheme = if (darkTheme) {
-        darkColorScheme(
-            primary = Purple80,
-            secondary = PurpleGrey80
-        )
-    } else {
-        lightColorScheme(
-            primary = Purple40,
-            secondary = PurpleGrey40
-        )
-    }
-
-    MaterialTheme(
-        colorScheme = colorScheme,
-        typography = Typography,
-        content = content
-    )
-}
-\`\`\`
-
-## Best Practices
-
-1. **Stateless composables** - Pass state down, events up
-2. **Remember wisely** - Use \`remember\` for expensive calculations
-3. **Lifecycle-aware collection** - Use \`collectAsStateWithLifecycle()\`
-4. **Modifier parameter** - Always accept Modifier as last parameter
-5. **Preview annotations** - Add @Preview for rapid iteration
-`,
-    isNew: true
-  };
-}
-function generateAndroidViewsSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/android-views-patterns.md",
-    content: `---
-name: android-views-patterns
-description: Android XML views and traditional patterns
-globs:
-  - "**/*.kt"
-  - "**/*.xml"
----
-
-# Android Views Patterns
-
-## Activity Structure
-
-\`\`\`kotlin
-class MainActivity : AppCompatActivity() {
-
-    private lateinit var binding: ActivityMainBinding
-    private val viewModel: MainViewModel by viewModels()
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        binding = ActivityMainBinding.inflate(layoutInflater)
-        setContentView(binding.root)
-
-        setupUI()
-        observeViewModel()
-    }
-
-    private fun setupUI() {
-        binding.recyclerView.apply {
-            layoutManager = LinearLayoutManager(this@MainActivity)
-            adapter = userAdapter
-        }
-
-        binding.swipeRefresh.setOnRefreshListener {
-            viewModel.refresh()
-        }
-    }
-
-    private fun observeViewModel() {
-        lifecycleScope.launch {
-            repeatOnLifecycle(Lifecycle.State.STARTED) {
-                viewModel.uiState.collect { state ->
-                    updateUI(state)
-                }
-            }
-        }
-    }
-
-    private fun updateUI(state: MainUiState) {
-        binding.swipeRefresh.isRefreshing = state.isLoading
-        userAdapter.submitList(state.users)
-        binding.errorText.isVisible = state.error != null
-        binding.errorText.text = state.error
-    }
-}
-\`\`\`
-
-## Fragment Pattern
-
-\`\`\`kotlin
-class UserFragment : Fragment(R.layout.fragment_user) {
-
-    private var _binding: FragmentUserBinding? = null
-    private val binding get() = _binding!!
-
-    private val viewModel: UserViewModel by viewModels()
-    private val args: UserFragmentArgs by navArgs()
-
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-        _binding = FragmentUserBinding.bind(view)
-
-        setupUI()
-        observeViewModel()
-        viewModel.loadUser(args.userId)
-    }
-
-    override fun onDestroyView() {
-        super.onDestroyView()
-        _binding = null
-    }
-}
-\`\`\`
-
-## RecyclerView Adapter
-
-\`\`\`kotlin
-class UserAdapter(
-    private val onItemClick: (User) -> Unit
-) : ListAdapter<User, UserAdapter.ViewHolder>(UserDiffCallback()) {
-
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
-        val binding = ItemUserBinding.inflate(
-            LayoutInflater.from(parent.context),
-            parent,
-            false
-        )
-        return ViewHolder(binding)
-    }
-
-    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        holder.bind(getItem(position))
-    }
-
-    inner class ViewHolder(
-        private val binding: ItemUserBinding
-    ) : RecyclerView.ViewHolder(binding.root) {
-
-        init {
-            binding.root.setOnClickListener {
-                onItemClick(getItem(adapterPosition))
-            }
-        }
-
-        fun bind(user: User) {
-            binding.nameText.text = user.name
-            binding.emailText.text = user.email
-            Glide.with(binding.avatar)
-                .load(user.avatarUrl)
-                .circleCrop()
-                .into(binding.avatar)
-        }
-    }
-
-    class UserDiffCallback : DiffUtil.ItemCallback<User>() {
-        override fun areItemsTheSame(oldItem: User, newItem: User) =
-            oldItem.id == newItem.id
-
-        override fun areContentsTheSame(oldItem: User, newItem: User) =
-            oldItem == newItem
-    }
-}
-\`\`\`
-
-## XML Layout
-
-\`\`\`xml
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-
-    <com.google.android.material.appbar.MaterialToolbar
-        android:id="@+id/toolbar"
-        android:layout_width="0dp"
-        android:layout_height="?attr/actionBarSize"
-        app:title="Users"
-        app:layout_constraintTop_toTopOf="parent"
-        app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintEnd_toEndOf="parent" />
-
-    <androidx.swiperefreshlayout.widget.SwipeRefreshLayout
-        android:id="@+id/swipeRefresh"
-        android:layout_width="0dp"
-        android:layout_height="0dp"
-        app:layout_constraintTop_toBottomOf="@id/toolbar"
-        app:layout_constraintBottom_toBottomOf="parent"
-        app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintEnd_toEndOf="parent">
-
-        <androidx.recyclerview.widget.RecyclerView
-            android:id="@+id/recyclerView"
-            android:layout_width="match_parent"
-            android:layout_height="match_parent" />
-
-    </androidx.swiperefreshlayout.widget.SwipeRefreshLayout>
-
-</androidx.constraintlayout.widget.ConstraintLayout>
-\`\`\`
-
-## ViewModel with Repository
-
-\`\`\`kotlin
-@HiltViewModel
-class UserViewModel @Inject constructor(
-    private val repository: UserRepository,
-    private val savedStateHandle: SavedStateHandle
-) : ViewModel() {
-
-    private val _uiState = MutableStateFlow(UserUiState())
-    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
-
-    fun loadUsers() {
-        viewModelScope.launch {
-            _uiState.update { it.copy(isLoading = true) }
-            try {
-                val users = repository.getUsers()
-                _uiState.update { it.copy(users = users, isLoading = false) }
-            } catch (e: Exception) {
-                _uiState.update { it.copy(error = e.message, isLoading = false) }
-            }
-        }
-    }
-}
-
-data class UserUiState(
-    val users: List<User> = emptyList(),
-    val isLoading: Boolean = false,
-    val error: String? = null
-)
-\`\`\`
-
-## Best Practices
-
-1. **View Binding** - Use over findViewById or synthetic imports
-2. **Lifecycle awareness** - Collect flows in repeatOnLifecycle
-3. **ListAdapter** - For efficient RecyclerView updates
-4. **Navigation Component** - For fragment navigation
-5. **Clean up bindings** - Set to null in onDestroyView
-`,
-    isNew: true
-  };
-}
-function generateIterativeDevelopmentSkill(stack) {
-  const testCmd = getTestCommand(stack);
-  const lintCmd = getLintCommand(stack);
-  return {
-    type: "skill",
-    path: ".claude/skills/iterative-development.md",
-    content: `---
-name: iterative-development
-description: TDD-driven iterative loops until tests pass
-globs:
-  - "**/*.ts"
-  - "**/*.tsx"
-  - "**/*.js"
-  - "**/*.py"
-  - "**/*.go"
----
-
-# Iterative Development (TDD Loops)
-
-Self-referential development loops where you iterate until completion criteria are met.
-
-## Core Philosophy
-
-\`\`\`
-\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
-\u2502  ITERATION > PERFECTION                                     \u2502
-\u2502  Don't aim for perfect on first try.                        \u2502
-\u2502  Let the loop refine the work.                              \u2502
-\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
-\u2502  FAILURES ARE DATA                                          \u2502
-\u2502  Failed tests, lint errors, type mismatches are signals.    \u2502
-\u2502  Use them to guide the next iteration.                      \u2502
-\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
-\u2502  CLEAR COMPLETION CRITERIA                                  \u2502
-\u2502  Define exactly what "done" looks like.                     \u2502
-\u2502  Tests passing. Coverage met. Lint clean.                   \u2502
-\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
-\`\`\`
-
-## TDD Workflow (Mandatory)
-
-Every implementation task MUST follow this workflow:
-
-### 1. RED: Write Tests First
-\`\`\`bash
-# Write tests based on requirements
-# Run tests - they MUST FAIL
-${testCmd}
-\`\`\`
-
-### 2. GREEN: Implement Feature
-\`\`\`bash
-# Write minimum code to pass tests
-# Run tests - they MUST PASS
-${testCmd}
-\`\`\`
-
-### 3. VALIDATE: Quality Gates
-\`\`\`bash
-# Full quality check
-${lintCmd ? `${lintCmd} && ` : ""}${testCmd}
-\`\`\`
-
-## Completion Criteria Template
-
-For any implementation task, define:
-
-\`\`\`markdown
-### Completion Criteria
-- [ ] All tests passing
-- [ ] Coverage >= 80% (on new code)
-- [ ] Lint clean (no errors)
-- [ ] Type check passing
-\`\`\`
-
-## When to Use This Workflow
-
-| Task Type | Use TDD Loop? |
-|-----------|---------------|
-| New feature | \u2705 Always |
-| Bug fix | \u2705 Always (write test that reproduces bug first) |
-| Refactoring | \u2705 Always (existing tests must stay green) |
-| Spike/exploration | \u274C Skip (but document findings) |
-| Documentation | \u274C Skip |
-
-## Anti-Patterns
-
-- \u274C Writing code before tests
-- \u274C Skipping the RED phase (tests that never fail are useless)
-- \u274C Moving on when tests fail
-- \u274C Large batches (prefer small, focused iterations)
-`,
-    isNew: true
-  };
-}
-function generateCommitHygieneSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/commit-hygiene.md",
-    content: `---
-name: commit-hygiene
-description: Atomic commits, PR size limits, commit thresholds
-globs:
-  - "**/*"
----
-
-# Commit Hygiene
-
-Keep commits atomic, PRs reviewable, and git history clean.
-
-## Size Thresholds
-
-| Metric | \u{1F7E2} Good | \u{1F7E1} Warning | \u{1F534} Commit Now |
-|--------|---------|------------|---------------|
-| Files changed | 1-5 | 6-10 | > 10 |
-| Lines added | < 150 | 150-300 | > 300 |
-| Total changes | < 250 | 250-400 | > 400 |
-
-**Research shows:** PRs > 400 lines have 40%+ defect rates vs 15% for smaller changes.
-
-## When to Commit
-
-### Commit Triggers (Any = Commit)
-
-| Trigger | Action |
-|---------|--------|
-| Test passes | Just got a test green \u2192 commit |
-| Feature complete | Finished a function \u2192 commit |
-| Refactor done | Renamed across files \u2192 commit |
-| Bug fixed | Fixed the issue \u2192 commit |
-| Threshold hit | > 5 files or > 200 lines \u2192 commit |
-
-### Commit Immediately If
-
-- \u2705 Tests are passing after being red
-- \u2705 You're about to make a "big change"
-- \u2705 You've been coding for 30+ minutes
-- \u2705 You're about to try something risky
-- \u2705 The current state is "working"
-
-## Atomic Commit Patterns
-
-### Good Commits \u2705
-
-\`\`\`
-"Add email validation to signup form"
-- 3 files: validator.ts, signup.tsx, signup.test.ts
-- 120 lines changed
-- Single purpose: email validation
-
-"Fix null pointer in user lookup"
-- 2 files: userService.ts, userService.test.ts
-- 25 lines changed
-- Single purpose: fix one bug
-\`\`\`
-
-### Bad Commits \u274C
-
-\`\`\`
-"Add authentication, fix bugs, update styles"
-- 25 files changed, 800 lines
-- Multiple unrelated purposes
-
-"WIP" / "Updates" / "Fix stuff"
-- Unknown scope, no clear purpose
-\`\`\`
-
-## Quick Status Check
-
-Run frequently to check current state:
-
-\`\`\`bash
-# See what's changed
-git status --short
-
-# Count changes
-git diff --shortstat
-
-# Full summary
-git diff --stat HEAD
-\`\`\`
-
-## PR Size Rules
-
-| PR Size | Review Time | Quality |
-|---------|-------------|---------|
-| < 200 lines | < 30 min | High confidence |
-| 200-400 lines | 30-60 min | Good confidence |
-| 400-1000 lines | 1-2 hours | Declining quality |
-| > 1000 lines | Often skipped | Rubber-stamped |
-
-**Best practice:** If a PR will be > 400 lines, split into stacked PRs.
-`,
-    isNew: true
-  };
-}
-function generateCodeDeduplicationSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/code-deduplication.md",
-    content: `---
-name: code-deduplication
-description: Prevent semantic code duplication with capability index
-globs:
-  - "**/*.ts"
-  - "**/*.tsx"
-  - "**/*.js"
-  - "**/*.py"
----
-
-# Code Deduplication
-
-Prevent semantic duplication by maintaining awareness of existing capabilities.
-
-## Core Principle
-
-\`\`\`
-\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
-\u2502  CHECK BEFORE YOU WRITE                                         \u2502
-\u2502  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2502
-\u2502  AI doesn't copy/paste - it reimplements.                       \u2502
-\u2502  The problem isn't duplicate code, it's duplicate PURPOSE.      \u2502
-\u2502                                                                 \u2502
-\u2502  Before writing ANY new function:                               \u2502
-\u2502  1. Search codebase for similar functionality                   \u2502
-\u2502  2. Check utils/, helpers/, lib/ for existing implementations   \u2502
-\u2502  3. Extend existing code if possible                            \u2502
-\u2502  4. Only create new if nothing suitable exists                  \u2502
-\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
-\`\`\`
-
-## Before Writing New Code
-
-### Search Checklist
-
-1. **Search by purpose**: "format date", "validate email", "fetch user"
-2. **Search common locations**:
-   - \`src/utils/\` or \`lib/\`
-   - \`src/helpers/\`
-   - \`src/common/\`
-   - \`src/shared/\`
-3. **Search by function signature**: Similar inputs/outputs
-
-### Common Duplicate Candidates
-
-| Category | Look For |
-|----------|----------|
-| Date/Time | formatDate, parseDate, isExpired, addDays |
-| Validation | isEmail, isPhone, isURL, isUUID |
-| Strings | slugify, truncate, capitalize, pluralize |
-| API | fetchUser, createItem, handleError |
-| Auth | validateToken, requireAuth, getCurrentUser |
-
-## If Similar Code Exists
-
-### Option 1: Reuse directly
-\`\`\`typescript
-// Import and use existing function
-import { formatDate } from '@/utils/dates';
-\`\`\`
-
-### Option 2: Extend with options
-\`\`\`typescript
-// Add optional parameter to existing function
-export function formatDate(
-  date: Date,
-  format: string = 'short',
-  locale?: string  // NEW: added locale support
-): string { ... }
-\`\`\`
-
-### Option 3: Compose from existing
-\`\`\`typescript
-// Build on existing utilities
-export function formatDateRange(start: Date, end: Date) {
-  return \`\${formatDate(start)} - \${formatDate(end)}\`;
-}
-\`\`\`
-
-## File Header Pattern
-
-Document what each file provides:
-
-\`\`\`typescript
-/**
- * @file User validation utilities
- * @description Email, phone, and identity validation functions.
- *
- * Key exports:
- * - isEmail(email) - Validates email format
- * - isPhone(phone, country?) - Validates phone with country
- * - isValidUsername(username) - Checks username rules
- */
-\`\`\`
-
-## Anti-Patterns
-
-- \u274C Writing date formatter without checking utils/
-- \u274C Creating new API client when one exists
-- \u274C Duplicating validation logic across files
-- \u274C Copy-pasting functions between files
-- \u274C "I'll refactor later" (you won't)
-`,
-    isNew: true
-  };
-}
-function generateSimplicityRulesSkill() {
-  return {
-    type: "skill",
-    path: ".claude/skills/simplicity-rules.md",
-    content: `---
-name: simplicity-rules
-description: Enforced code complexity constraints
-globs:
-  - "**/*.ts"
-  - "**/*.tsx"
-  - "**/*.js"
-  - "**/*.py"
-  - "**/*.go"
----
-
-# Simplicity Rules
-
-Complexity is the enemy. Every line of code is a liability.
-
-## Enforced Limits
-
-**CRITICAL: These limits are non-negotiable. Check and enforce for EVERY file.**
-
-### Function Level
-
-| Constraint | Limit | Action if Exceeded |
-|------------|-------|-------------------|
-| Lines per function | 20 max | Decompose immediately |
-| Parameters | 3 max | Use options object |
-| Nesting levels | 2 max | Flatten with early returns |
-
-### File Level
-
-| Constraint | Limit | Action if Exceeded |
-|------------|-------|-------------------|
-| Lines per file | 200 max | Split by responsibility |
-| Functions per file | 10 max | Split into modules |
-
-### Module Level
-
-| Constraint | Limit | Reason |
-|------------|-------|--------|
-| Directory nesting | 3 levels max | Flat is better |
-| Circular deps | 0 | Never acceptable |
-
-## Enforcement Protocol
-
-**Before completing ANY file:**
-
-\`\`\`
-1. Count total lines     \u2192 if > 200, STOP and split
-2. Count functions       \u2192 if > 10, STOP and split
-3. Check function length \u2192 if any > 20 lines, decompose
-4. Check parameters      \u2192 if any > 3, refactor to options object
-\`\`\`
-
-## Violation Response
-
-When limits are exceeded:
-
-\`\`\`
-\u26A0\uFE0F FILE SIZE VIOLATION DETECTED
-
-[filename] has [X] lines (limit: 200)
-
-Splitting into:
-- [filename-a].ts - [responsibility A]
-- [filename-b].ts - [responsibility B]
-\`\`\`
-
-**Never defer refactoring.** Fix violations immediately.
-
-## Decomposition Patterns
-
-### Long Function \u2192 Multiple Functions
-
-\`\`\`typescript
-// BEFORE: 40 lines
-function processOrder(order) {
-  // validate... 10 lines
-  // calculate totals... 15 lines
-  // apply discounts... 10 lines
-  // save... 5 lines
-}
-
-// AFTER: 4 functions, each < 15 lines
-function processOrder(order) {
-  validateOrder(order);
-  const totals = calculateTotals(order);
-  const finalPrice = applyDiscounts(totals, order.coupons);
-  return saveOrder({ ...order, finalPrice });
-}
-\`\`\`
-
-### Many Parameters \u2192 Options Object
-
-\`\`\`typescript
-// BEFORE: 6 parameters
-function createUser(name, email, password, role, team, settings) { }
-
-// AFTER: 1 options object
-interface CreateUserOptions {
-  name: string;
-  email: string;
-  password: string;
-  role?: string;
-  team?: string;
-  settings?: UserSettings;
-}
-function createUser(options: CreateUserOptions) { }
-\`\`\`
-
-### Deep Nesting \u2192 Early Returns
-
-\`\`\`typescript
-// BEFORE: 4 levels deep
-function process(data) {
-  if (data) {
-    if (data.valid) {
-      if (data.items) {
-        for (const item of data.items) {
-          // actual logic here
-        }
-      }
-    }
-  }
-}
-
-// AFTER: 1 level deep
-function process(data) {
-  if (!data?.valid || !data.items) return;
-
-  for (const item of data.items) {
-    // actual logic here
-  }
-}
-\`\`\`
-
-## Anti-Patterns
-
-- \u274C God objects/files (do everything)
-- \u274C "Just one more line" (compound violations)
-- \u274C "I'll split it later" (you won't)
-- \u274C Deep inheritance hierarchies
-- \u274C Complex conditionals without extraction
-`,
-    isNew: true
-  };
-}
-function generateSecuritySkill(stack) {
-  const isJS = stack.languages.includes("typescript") || stack.languages.includes("javascript");
-  const isPython = stack.languages.includes("python");
-  return {
-    type: "skill",
-    path: ".claude/skills/security.md",
-    content: `---
-name: security
-description: Security best practices, secrets management, OWASP patterns
-globs:
-  - "**/*"
----
-
-# Security Best Practices
-
-Security is not optional. Every project must pass security checks.
-
-## Required .gitignore Entries
-
-**NEVER commit these:**
-
-\`\`\`gitignore
-# Environment files
-.env
-.env.*
-!.env.example
-
-# Secrets and credentials
-*.pem
-*.key
-*.p12
-credentials.json
-secrets.json
-*-credentials.json
-service-account*.json
-
-# IDE secrets
-.idea/
-.vscode/settings.json
-\`\`\`
-
-## Environment Variables
-
-### Create .env.example
-
-Document required vars without values:
-
-\`\`\`bash
-# Server-side only (never expose to client)
-DATABASE_URL=
-API_SECRET_KEY=
-ANTHROPIC_API_KEY=
-
-# Client-side safe (public, non-sensitive)
-${isJS ? "VITE_API_URL=\nNEXT_PUBLIC_SITE_URL=" : "API_BASE_URL="}
-\`\`\`
-
-${isJS ? `### Frontend Exposure Rules
-
-| Framework | Client-Exposed Prefix | Server-Only |
-|-----------|----------------------|-------------|
-| Vite | \`VITE_*\` | No prefix |
-| Next.js | \`NEXT_PUBLIC_*\` | No prefix |
-| CRA | \`REACT_APP_*\` | N/A |
-
-**CRITICAL:** Never put secrets in client-exposed env vars!
-
-\`\`\`typescript
-// \u274C WRONG - Secret exposed to browser
-const key = import.meta.env.VITE_API_SECRET;
-
-// \u2705 CORRECT - Secret stays server-side
-const key = process.env.API_SECRET; // in API route only
-\`\`\`
-` : ""}
-
-### Validate at Startup
-
-${isJS ? `\`\`\`typescript
-import { z } from 'zod';
-
-const envSchema = z.object({
-  DATABASE_URL: z.string().url(),
-  API_SECRET_KEY: z.string().min(32),
-  NODE_ENV: z.enum(['development', 'production', 'test']),
-});
-
-export const env = envSchema.parse(process.env);
-\`\`\`` : ""}
-${isPython ? `\`\`\`python
-from pydantic_settings import BaseSettings
-
-class Settings(BaseSettings):
-    database_url: str
-    api_secret_key: str
-    environment: str = "development"
-
-    class Config:
-        env_file = ".env"
-
-settings = Settings()
-\`\`\`` : ""}
-
-## OWASP Top 10 Checklist
-
-| Vulnerability | Prevention |
-|---------------|------------|
-| Injection (SQL, NoSQL, Command) | Parameterized queries, input validation |
-| Broken Auth | Secure session management, MFA |
-| Sensitive Data Exposure | Encryption at rest and in transit |
-| XXE | Disable external entity processing |
-| Broken Access Control | Verify permissions on every request |
-| Security Misconfiguration | Secure defaults, minimal permissions |
-| XSS | Output encoding, CSP headers |
-| Insecure Deserialization | Validate all serialized data |
-| Using Vulnerable Components | Keep dependencies updated |
-| Insufficient Logging | Log security events, monitor |
-
-## Input Validation
-
-\`\`\`
-RULE: Never trust user input. Validate everything.
-
-- Validate type, length, format, range
-- Sanitize before storage
-- Encode before output
-- Use allowlists over denylists
-\`\`\`
-
-## Secrets Detection
-
-Before committing, check for:
-
-- API keys (usually 32+ chars, specific patterns)
-- Passwords in code
-- Connection strings with credentials
-- Private keys (BEGIN RSA/EC/PRIVATE KEY)
-- Tokens (jwt, bearer, oauth)
-
-## Security Review Checklist
-
-Before PR merge:
-
-- [ ] No secrets in code or config
-- [ ] Input validation on all user data
-- [ ] Output encoding where displayed
-- [ ] Authentication checked on protected routes
-- [ ] Authorization verified for resources
-- [ ] Dependencies scanned for vulnerabilities
-- [ ] Error messages don't leak internals
-`,
-    isNew: true
-  };
-}
-function generateAgents(stack) {
-  const artifacts = [];
-  artifacts.push(generateCodeReviewerAgent(stack));
-  artifacts.push(generateTestWriterAgent(stack));
-  return artifacts;
-}
-function generateCodeReviewerAgent(stack) {
-  const lintCommand = getLintCommand(stack);
-  return {
-    type: "agent",
-    path: ".claude/agents/code-reviewer.md",
-    content: `---
-name: code-reviewer
-description: Reviews code for quality, security issues, and best practices
-tools: Read, Grep, Glob${lintCommand ? `, Bash(${lintCommand})` : ""}
-disallowedTools: Write, Edit
-model: sonnet
----
-
-You are a senior code reviewer with expertise in security and performance.
-
-## Code Style Reference
-
-Read these files to understand project conventions:
-${stack.linter === "eslint" ? "- `eslint.config.js` or `.eslintrc.*`" : ""}
-${stack.formatter === "prettier" ? "- `.prettierrc`" : ""}
-${stack.languages.includes("typescript") ? "- `tsconfig.json`" : ""}
-${stack.languages.includes("python") ? "- `pyproject.toml` or `setup.cfg`" : ""}
-
-${lintCommand ? `Run \`${lintCommand}\` to check violations programmatically.` : ""}
-
-## Review Process
-
-1. Run \`git diff\` to identify changed files
-2. Analyze each change for:
-   - Security vulnerabilities (OWASP Top 10)
-   - Performance issues
-   - Code style violations
-   - Missing error handling
-   - Test coverage gaps
-
-## Output Format
-
-For each finding:
-
-- **Critical**: Must fix before merge
-- **Warning**: Should address
-- **Suggestion**: Consider improving
-
-Include file:line references for each issue.
-`,
-    isNew: true
-  };
-}
-function generateTestWriterAgent(stack) {
-  const testCommand = getTestCommand(stack);
-  return {
-    type: "agent",
-    path: ".claude/agents/test-writer.md",
-    content: `---
-name: test-writer
-description: Generates comprehensive tests for code
-tools: Read, Grep, Glob, Write, Edit, Bash(${testCommand})
-model: sonnet
----
-
-You are a testing expert who writes thorough, maintainable tests.
-
-## Testing Framework
-
-This project uses: **${stack.testingFramework || "unknown"}**
-
-## Your Process
-
-1. Read the code to be tested
-2. Identify test cases:
-   - Happy path scenarios
-   - Edge cases
-   - Error conditions
-   - Boundary values
-3. Write tests following project patterns
-4. Run tests to verify they pass
-
-## Test Structure
-
-Follow the AAA pattern:
-- **Arrange**: Set up test data
-- **Act**: Execute the code
-- **Assert**: Verify results
-
-## Guidelines
-
-- One assertion focus per test
-- Descriptive test names
-- Mock external dependencies
-- Don't test implementation details
-- Aim for behavior coverage
-
-## Run Tests
-
-\`\`\`bash
-${testCommand}
-\`\`\`
-`,
-    isNew: true
-  };
-}
-function getLintCommand(stack) {
-  switch (stack.linter) {
-    case "eslint":
-      return `${stack.packageManager === "bun" ? "bun" : "npx"} eslint .`;
-    case "biome":
-      return `${stack.packageManager === "bun" ? "bun" : "npx"} biome check .`;
-    case "ruff":
-      return "ruff check .";
-    default:
-      return "";
-  }
-}
-function getTestCommand(stack) {
-  switch (stack.testingFramework) {
-    case "vitest":
-      return `${stack.packageManager || "npm"} ${stack.packageManager === "npm" ? "run " : ""}test`;
-    case "jest":
-      return `${stack.packageManager || "npm"} ${stack.packageManager === "npm" ? "run " : ""}test`;
-    case "bun-test":
-      return "bun test";
-    case "pytest":
-      return "pytest";
-    case "go-test":
-      return "go test ./...";
-    case "rust-test":
-      return "cargo test";
-    default:
-      return `${stack.packageManager || "npm"} test`;
-  }
-}
-function generateRules(stack) {
-  const artifacts = [];
-  if (stack.languages.includes("typescript")) {
-    artifacts.push(generateTypeScriptRules());
-  }
-  if (stack.languages.includes("python")) {
-    artifacts.push(generatePythonRules());
-  }
-  artifacts.push(generateCodeStyleRule(stack));
-  return artifacts;
-}
-function generateTypeScriptRules() {
-  return {
-    type: "rule",
-    path: ".claude/rules/typescript.md",
-    content: `---
-paths:
-  - "**/*.ts"
-  - "**/*.tsx"
----
-
-# TypeScript Rules
-
-## Type Safety
-
-- Avoid \`any\` - use \`unknown\` and narrow types
-- Prefer interfaces for objects, types for unions/intersections
-- Use strict mode (\`strict: true\` in tsconfig)
-- Enable \`noUncheckedIndexedAccess\` for safer array access
-
-## Patterns
-
-\`\`\`typescript
-// Prefer
-const user: User | undefined = users.find(u => u.id === id);
-if (user) { /* use user */ }
-
-// Avoid
-const user = users.find(u => u.id === id) as User;
-\`\`\`
-
-## Naming
-
-- Interfaces: PascalCase (e.g., \`UserProfile\`)
-- Types: PascalCase (e.g., \`ApiResponse\`)
-- Functions: camelCase (e.g., \`getUserById\`)
-- Constants: SCREAMING_SNAKE_CASE for true constants
-
-## Imports
-
-- Group imports: external, internal, relative
-- Use path aliases when configured
-- Prefer named exports over default exports
-`,
-    isNew: true
-  };
-}
-function generatePythonRules() {
-  return {
-    type: "rule",
-    path: ".claude/rules/python.md",
-    content: `---
-paths:
-  - "**/*.py"
----
-
-# Python Rules
-
-## Style
-
-- Follow PEP 8
-- Use type hints for function signatures
-- Docstrings for public functions (Google style)
-- Max line length: 88 (Black default)
-
-## Patterns
-
-\`\`\`python
-# Prefer
-def get_user(user_id: int) -> User | None:
-    """Fetch user by ID.
-
-    Args:
-        user_id: The user's unique identifier.
-
-    Returns:
-        User object if found, None otherwise.
-    """
-    return db.query(User).filter(User.id == user_id).first()
-
-# Avoid
-def get_user(id):
-    return db.query(User).filter(User.id == id).first()
-\`\`\`
-
-## Naming
-
-- Functions/variables: snake_case
-- Classes: PascalCase
-- Constants: SCREAMING_SNAKE_CASE
-- Private: _leading_underscore
-
-## Imports
-
-\`\`\`python
-# Standard library
-import os
-from pathlib import Path
-
-# Third-party
-from fastapi import FastAPI
-from pydantic import BaseModel
-
-# Local
-from app.models import User
-from app.services import UserService
-\`\`\`
-`,
-    isNew: true
-  };
-}
-function generateCodeStyleRule(stack) {
-  return {
-    type: "rule",
-    path: ".claude/rules/code-style.md",
-    content: `# Code Style
-
-## General Principles
-
-1. **Clarity over cleverness** - Code is read more than written
-2. **Consistency** - Match existing patterns in the codebase
-3. **Simplicity** - Prefer simple solutions over complex ones
-
-## Formatting
-
-${stack.formatter ? `This project uses **${stack.formatter}** for formatting. Run it before committing.` : "Format code consistently with the existing codebase."}
-
-${stack.linter ? `This project uses **${stack.linter}** for linting. Fix all warnings.` : ""}
-
-## Comments
-
-- Write self-documenting code first
-- Comment the "why", not the "what"
-- Keep comments up to date with code changes
-- Use TODO/FIXME with context
-
-## Error Handling
-
-- Handle errors at appropriate boundaries
-- Provide meaningful error messages
-- Log errors with context
-- Don't swallow errors silently
-
-## Git Commits
-
-- Write clear, concise commit messages
-- Use conventional commits format when applicable
-- Keep commits focused and atomic
-`,
-    isNew: true
-  };
-}
-function generateCommands() {
-  return [
-    generateTaskCommand(),
-    generateStatusCommand(),
-    generateDoneCommand(),
-    generateAnalyzeCommand(),
-    generateCodeReviewCommand()
-  ];
-}
-function generateTaskCommand() {
-  return {
-    type: "command",
-    path: ".claude/commands/task.md",
-    content: `---
-allowed-tools: Read, Write, Edit, Glob, Grep
-argument-hint: [task description]
-description: Start or switch to a new task
----
-
-# Start Task
-
-## Current State
-!cat .claude/state/task.md 2>/dev/null || echo "No existing task"
-
-## Your Task
-
-Start or switch to the task: **$ARGUMENTS**
-
-1. Read current state from \`.claude/state/task.md\`
-2. If switching tasks, summarize previous progress
-3. Update \`.claude/state/task.md\` with:
-   - Status: In Progress
-   - Task description
-   - Initial context/understanding
-   - Planned next steps
-
-4. Begin working on the task
-`,
-    isNew: true
-  };
-}
-function generateStatusCommand() {
-  return {
-    type: "command",
-    path: ".claude/commands/status.md",
-    content: `---
-allowed-tools: Read, Glob
-description: Show current task and session state
----
-
-# Status Check
-
-## Current Task State
-!cat .claude/state/task.md 2>/dev/null || echo "No task in progress"
-
-## Your Response
-
-Provide a concise status update:
-
-1. **Current Task**: What are you working on?
-2. **Progress**: What's been completed?
-3. **Blockers**: Any issues or questions?
-4. **Next Steps**: What's coming up?
-
-Keep it brief - this is a quick check-in.
-`,
-    isNew: true
-  };
-}
-function generateDoneCommand() {
-  return {
-    type: "command",
-    path: ".claude/commands/done.md",
-    content: `---
-allowed-tools: Read, Write, Edit, Glob, Bash(git diff), Bash(git status)
-description: Mark current task complete
----
-
-# Complete Task
-
-## Current State
-!cat .claude/state/task.md
-
-## Completion Checklist
-
-Before marking complete, verify:
-
-1. [ ] All requirements met
-2. [ ] Tests pass (if applicable)
-3. [ ] No linting errors
-4. [ ] Code reviewed for quality
-
-## Your Task
-
-1. Run final checks (tests, lint)
-2. Update \`.claude/state/task.md\`:
-   - Status: **Completed**
-   - Summary of what was done
-   - Files changed
-   - Any follow-up items
-
-3. Show git status/diff for review
-`,
-    isNew: true
+  const permissions = ["Read(**)", "Edit(**)", "Write(.claude/**)", "Bash(git:*)"];
+  const pkgManagers = ["npm", "yarn", "pnpm", "bun", "npx"];
+  for (const pm of pkgManagers) {
+    permissions.push(`Bash(${pm}:*)`);
+  }
+  if (stack.languages.includes("typescript") || stack.languages.includes("javascript")) {
+    permissions.push("Bash(node:*)", "Bash(tsc:*)");
+  }
+  if (stack.languages.includes("python")) {
+    permissions.push(
+      "Bash(python:*)",
+      "Bash(pip:*)",
+      "Bash(poetry:*)",
+      "Bash(pytest:*)",
+      "Bash(uvicorn:*)"
+    );
+  }
+  if (stack.languages.includes("go")) {
+    permissions.push("Bash(go:*)");
+  }
+  if (stack.languages.includes("rust")) {
+    permissions.push("Bash(cargo:*)", "Bash(rustc:*)");
+  }
+  if (stack.languages.includes("ruby")) {
+    permissions.push("Bash(ruby:*)", "Bash(bundle:*)", "Bash(rails:*)", "Bash(rake:*)");
+  }
+  if (stack.testingFramework) {
+    const testCommands = {
+      jest: ["jest:*"],
+      vitest: ["vitest:*"],
+      playwright: ["playwright:*"],
+      cypress: ["cypress:*"],
+      pytest: ["pytest:*"],
+      rspec: ["rspec:*"]
+    };
+    const cmds = testCommands[stack.testingFramework];
+    if (cmds) {
+      permissions.push(...cmds.map((c) => `Bash(${c})`));
+    }
+  }
+  if (stack.linter) {
+    permissions.push(`Bash(${stack.linter}:*)`);
+  }
+  if (stack.formatter) {
+    permissions.push(`Bash(${stack.formatter}:*)`);
+  }
+  permissions.push(
+    "Bash(ls:*)",
+    "Bash(mkdir:*)",
+    "Bash(cat:*)",
+    "Bash(echo:*)",
+    "Bash(grep:*)",
+    "Bash(find:*)"
+  );
+  if (stack.hasDocker) {
+    permissions.push("Bash(docker:*)", "Bash(docker-compose:*)");
+  }
+  const settings = {
+    $schema: "https://json.schemastore.org/claude-code-settings.json",
+    permissions: {
+      allow: [...new Set(permissions)]
+      // Deduplicate
+    }
   };
-}
-function generateAnalyzeCommand() {
   return {
-    type: "command",
-    path: ".claude/commands/analyze.md",
-    content: `---
-allowed-tools: Read, Glob, Grep
-argument-hint: [area to analyze]
-description: Deep analysis of a specific area
----
-
-# Analyze: $ARGUMENTS
-
-## Analysis Scope
-
-Perform deep analysis of: **$ARGUMENTS**
-
-## Process
-
-1. **Locate relevant files** using Glob and Grep
-2. **Read and understand** the code structure
-3. **Identify patterns** and conventions
-4. **Document findings** with file:line references
-
-## Output Format
-
-### Overview
-Brief description of what this area does.
-
-### Key Files
-- \`path/to/file.ts:10\` - Purpose
-
-### Patterns Found
-- Pattern 1: Description
-- Pattern 2: Description
-
-### Dependencies
-What this area depends on and what depends on it.
-
-### Recommendations
-Any improvements or concerns noted.
-`,
-    isNew: true
+    path: ".claude/settings.json",
+    content: JSON.stringify(settings, null, 2)
   };
 }
-function generateCodeReviewCommand() {
-  return {
-    type: "command",
-    path: ".claude/commands/code-review.md",
-    content: `---
-allowed-tools: Read, Glob, Grep, Bash(git diff), Bash(git status), Bash(git log)
-description: Review code changes for quality, security, and best practices
----
-
-# Code Review
-
-## Changes to Review
-
-!git diff --stat HEAD~1 2>/dev/null || git diff --stat
-
-## Review Process
-
-Analyze all changes for:
-
-### 1. Security (Critical)
-- [ ] No secrets/credentials in code
-- [ ] Input validation present
-- [ ] Output encoding where needed
-- [ ] Auth/authz checks on protected routes
-
-### 2. Quality
-- [ ] Functions \u2264 20 lines
-- [ ] Files \u2264 200 lines
-- [ ] No code duplication
-- [ ] Clear naming
-- [ ] Proper error handling
-
-### 3. Testing
-- [ ] Tests exist for new code
-- [ ] Edge cases covered
-- [ ] Tests are meaningful (not just for coverage)
-
-### 4. Style
-- [ ] Matches existing patterns
-- [ ] Consistent formatting
-- [ ] No commented-out code
-
-## Output Format
-
-For each finding, include file:line reference:
-
-### Critical (Must Fix)
-Issues that block merge
-
-### Warning (Should Fix)
-Issues that should be addressed
-
-### Suggestion (Consider)
-Optional improvements
-
-## Summary
-
-Provide:
-1. Overall assessment (Ready / Changes Needed / Not Ready)
-2. Count of findings by severity
-3. Top priorities to address
-`,
-    isNew: true
-  };
+function writeSettings(rootDir, stack) {
+  const { path: settingsPath, content } = generateSettings(stack);
+  const fullPath = path2.join(rootDir, settingsPath);
+  const dir = path2.dirname(fullPath);
+  fs2.mkdirSync(dir, { recursive: true });
+  fs2.writeFileSync(fullPath, content);
 }
 
 // src/prompt.ts
 function getAnalysisPrompt(projectInfo) {
   const context = buildContextSection(projectInfo);
+  const templateVars = buildTemplateVariables(projectInfo);
   return `${ANALYSIS_PROMPT}
 
+${SKILLS_PROMPT}
+
+${AGENTS_PROMPT}
+
+${RULES_PROMPT}
+
+${COMMANDS_PROMPT}
+
 ---
 
 ## Pre-detected Context
@@ -3591,6 +647,10 @@ Use this as a starting point - verify and expand on it during your analysis.
 
 ${context}
 
+### Template Variables (use these in generated files)
+
+${templateVars}
+
 ---
 
 ## Execute Now
@@ -3600,9 +660,14 @@ ${context}
 3. Execute Phase 2 - generate the CLAUDE.md using only discovered information
 4. Execute Phase 3 - verify quality before writing
 5. Use the Write tool to create \`.claude/CLAUDE.md\` with the final content
-6. Output a brief summary of what was generated and any gaps found
+6. Execute Phase 4 - generate ALL skill files
+7. Execute Phase 5 - generate agent files
+8. Execute Phase 6 - generate rule files
+9. Execute Phase 7 - generate command files
+10. Output a brief summary of what was generated and any gaps found
 
-Do NOT output the full CLAUDE.md to stdout. Write it to disk using the Write tool.`;
+Do NOT output file contents to stdout. Write all files to disk using the Write tool.
+Generate ALL files in a single pass \u2014 do not stop after CLAUDE.md.`;
 }
 function buildContextSection(projectInfo) {
   const { name, description, techStack, fileCount } = projectInfo;
@@ -3654,11 +719,88 @@ function buildContextSection(projectInfo) {
   }
   return lines.join("\n");
 }
+function buildTemplateVariables(projectInfo) {
+  const { techStack } = projectInfo;
+  const vars = [];
+  vars.push(`- **detected_languages**: ${techStack.languages.join(", ") || "none detected"}`);
+  vars.push(`- **detected_frameworks**: ${techStack.frameworks.join(", ") || "none detected"}`);
+  vars.push(`- **detected_testing_framework**: ${techStack.testingFramework || "none detected"}`);
+  vars.push(`- **test_command**: ${getTestCommand(techStack)}`);
+  vars.push(`- **lint_command**: ${getLintCommand(techStack)}`);
+  vars.push(`- **detected_linter**: ${techStack.linter || "none detected"}`);
+  vars.push(`- **detected_formatter**: ${techStack.formatter || "none detected"}`);
+  vars.push(`- **source_glob_patterns**: ${getSourceGlobs(techStack)}`);
+  return vars.join("\n");
+}
+function getTestCommand(stack) {
+  if (stack.testingFramework) {
+    const commands = {
+      jest: "npx jest",
+      vitest: "npx vitest",
+      "bun-test": "bun test",
+      pytest: "pytest",
+      "go-test": "go test ./...",
+      "rust-test": "cargo test",
+      rspec: "bundle exec rspec",
+      junit: "mvn test",
+      mocha: "npx mocha",
+      playwright: "npx playwright test",
+      cypress: "npx cypress run",
+      unittest: "python -m unittest discover"
+    };
+    return commands[stack.testingFramework] || stack.testingFramework;
+  }
+  if (stack.packageManager === "bun") return "bun test";
+  if (stack.packageManager === "cargo") return "cargo test";
+  if (stack.packageManager === "go") return "go test ./...";
+  if (stack.packageManager) return `${stack.packageManager} test`;
+  return "npm test";
+}
+function getLintCommand(stack) {
+  if (stack.linter) {
+    const commands = {
+      eslint: "npx eslint .",
+      biome: "npx biome check .",
+      pylint: "pylint",
+      flake8: "flake8",
+      ruff: "ruff check .",
+      "golangci-lint": "golangci-lint run",
+      clippy: "cargo clippy",
+      rubocop: "bundle exec rubocop"
+    };
+    return commands[stack.linter] || stack.linter;
+  }
+  return "no linter detected";
+}
+function getSourceGlobs(stack) {
+  const globs = [];
+  for (const lang of stack.languages) {
+    const langGlobs = {
+      typescript: ["**/*.ts", "**/*.tsx"],
+      javascript: ["**/*.js", "**/*.jsx"],
+      python: ["**/*.py"],
+      go: ["**/*.go"],
+      rust: ["**/*.rs"],
+      java: ["**/*.java"],
+      ruby: ["**/*.rb"],
+      csharp: ["**/*.cs"],
+      swift: ["**/*.swift"],
+      kotlin: ["**/*.kt", "**/*.kts"],
+      php: ["**/*.php"],
+      cpp: ["**/*.cpp", "**/*.hpp", "**/*.h"]
+    };
+    const patterns = langGlobs[lang];
+    if (patterns) {
+      globs.push(...patterns);
+    }
+  }
+  return globs.length > 0 ? globs.join(", ") : "**/*";
+}
 var ANALYSIS_PROMPT = `You are a senior software architect performing a comprehensive codebase analysis.
-Your goal is to generate a professional \`.claude/CLAUDE.md\` file that gives Claude
+Your goal is to generate ALL \`.claude/\` configuration files that give Claude
 complete context to work effectively in this project.
 
-**This is NOT a generic template.** Every section must contain information specific to THIS
+**This is NOT a generic template.** Every file must contain information specific to THIS
 project, discovered through actual file reading and analysis. If you cannot determine
 something, omit that section entirely - do not fill in generic boilerplate.
 
@@ -3667,7 +809,7 @@ something, omit that section entirely - do not fill in generic boilerplate.
 ## Phase 1: Discovery (Read Before You Write)
 
 Perform these analysis steps IN ORDER. Do not skip any step. Do not start writing
-the CLAUDE.md until all discovery is complete.
+any files until all discovery is complete.
 
 ### 1.1 Project Identity
 
@@ -3901,6 +1043,264 @@ Before writing the CLAUDE.md, verify:
 5. **Keep it maintainable.** Don't include metrics that go stale quickly.
 
 6. **Respect existing CLAUDE.md.** If one exists, read it first and preserve manually-added sections.`;
+var SKILLS_PROMPT = `---
+
+## Phase 4: Generate Skills
+
+Write each skill file to \`.claude/skills/\` using the Write tool. Every skill must have
+YAML frontmatter with \`name\`, \`description\`, and optionally \`globs\` for file matching.
+
+**Tailor ALL skills to this specific project** \u2014 use the actual test command, lint command,
+file patterns, and conventions discovered during Phase 1.
+
+### 4.1 Core Skills (ALWAYS generate all 8)
+
+**\`.claude/skills/pattern-discovery.md\`**
+- Name: pattern-discovery
+- Description: Analyze codebase to discover and document patterns
+- Content: How to search for patterns in THIS project's structure. Include the actual source directories, key file patterns, and import conventions found.
+
+**\`.claude/skills/systematic-debugging.md\`**
+- Name: systematic-debugging
+- Description: 4-phase debugging methodology \u2014 Reproduce, Locate, Diagnose, Fix
+- Content: Tailor reproduction steps to the project's actual test runner and dev server commands. Include how to use the project's logging/debugging setup.
+
+**\`.claude/skills/testing-methodology.md\`**
+- Name: testing-methodology
+- Description: AAA testing pattern with project-specific framework syntax
+- Content: Use the project's actual testing framework syntax. Include real examples of test patterns found in the codebase (describe/it blocks, pytest fixtures, etc.). Reference the actual test command. Include mocking/stubbing patterns specific to the stack.
+
+**\`.claude/skills/iterative-development.md\`**
+- Name: iterative-development
+- Description: TDD workflow with project-specific test and lint commands
+- Content: The TDD loop using the actual test command and lint command. Include the project's verification steps (typecheck, build, etc.).
+
+**\`.claude/skills/commit-hygiene.md\`**
+- Name: commit-hygiene
+- Description: Atomic commits, conventional format, size thresholds
+- Content: Size thresholds (\xB1300 lines per commit), when-to-commit triggers, conventional commit format. If the project uses commitlint or similar, reference its config.
+
+**\`.claude/skills/code-deduplication.md\`**
+- Name: code-deduplication
+- Description: Check-before-write principle and search checklist
+- Content: Search existing code before writing new code. Include project-specific glob patterns for source files. Reference the actual directory structure for where to look.
+
+**\`.claude/skills/simplicity-rules.md\`**
+- Name: simplicity-rules
+- Description: Function and file size limits, decomposition patterns
+- Content: Function length limits (40 lines), file limits (300 lines), cyclomatic complexity. Decomposition patterns appropriate for the project's architecture style.
+
+**\`.claude/skills/security.md\`**
+- Name: security
+- Description: Security patterns and secrets management for this stack
+- Content: .gitignore entries appropriate for the detected stack. Environment variable handling patterns. OWASP checklist items relevant to the detected framework. Include actual secrets patterns to watch for (API keys, database URLs, etc.).
+
+### 4.2 Framework-Specific Skills (ONLY if detected)
+
+Generate the matching skill ONLY if the framework was detected in the tech stack:
+
+- **Next.js detected** \u2192 Write \`.claude/skills/nextjs-patterns.md\` \u2014 App Router patterns, Server/Client Components, data fetching (fetch, server actions), middleware, image optimization, caching strategies. Use patterns from the actual codebase.
+
+- **React (without Next.js) detected** \u2192 Write \`.claude/skills/react-components.md\` \u2014 Hooks patterns, component composition, state management (whatever is used), performance (memo, useMemo, useCallback), error boundaries.
+
+- **FastAPI detected** \u2192 Write \`.claude/skills/fastapi-patterns.md\` \u2014 Router organization, dependency injection, Pydantic models, async/await patterns, middleware, exception handlers.
+
+- **NestJS detected** \u2192 Write \`.claude/skills/nestjs-patterns.md\` \u2014 Module structure, controllers, services, decorators, pipes, guards, interceptors, custom providers.
+
+- **SwiftUI detected** \u2192 Write \`.claude/skills/swiftui-patterns.md\` \u2014 Property wrappers (@State, @Binding, @StateObject, @EnvironmentObject), MVVM, navigation (NavigationStack/NavigationSplitView), previews, accessibility.
+
+- **UIKit detected** \u2192 Write \`.claude/skills/uikit-patterns.md\` \u2014 View controller lifecycle, Auto Layout (programmatic and storyboard), delegates/datasources, MVC, coordinator pattern.
+
+- **Vapor detected** \u2192 Write \`.claude/skills/vapor-patterns.md\` \u2014 Routes, middleware, Fluent ORM, async controllers, content negotiation, validation.
+
+- **Jetpack Compose detected** \u2192 Write \`.claude/skills/compose-patterns.md\` \u2014 @Composable functions, remember/rememberSaveable, ViewModel integration, navigation, side effects (LaunchedEffect, DisposableEffect), theming.
+
+- **Android Views detected** \u2192 Write \`.claude/skills/android-views-patterns.md\` \u2014 Activities, Fragments, XML layouts, ViewBinding, RecyclerView, lifecycle awareness.
+
+- **Vue/Nuxt detected** \u2192 Write \`.claude/skills/vue-patterns.md\` \u2014 Composition API (ref, reactive, computed), composables, Pinia stores, routing, auto-imports.
+
+- **Django detected** \u2192 Write \`.claude/skills/django-patterns.md\` \u2014 Models, views (class-based and function-based), serializers, middleware, admin customization, signals.
+
+- **Rails detected** \u2192 Write \`.claude/skills/rails-patterns.md\` \u2014 MVC, ActiveRecord, concerns, service objects, jobs, mailers, strong parameters.
+
+- **Spring detected** \u2192 Write \`.claude/skills/spring-patterns.md\` \u2014 Beans, controllers, services, repositories, AOP, dependency injection, configuration properties.`;
+var AGENTS_PROMPT = `---
+
+## Phase 5: Generate Agents
+
+Write 2 agent files to \`.claude/agents/\`.
+
+### \`.claude/agents/code-reviewer.md\`
+
+YAML frontmatter:
+\`\`\`yaml
+---
+name: code-reviewer
+description: Reviews code for quality, security issues, and best practices
+tools:
+  - Read
+  - Grep
+  - Glob
+  - "Bash({lint_command})"
+disallowed_tools:
+  - Write
+  - Edit
+model: sonnet
+---
+\`\`\`
+
+Body content \u2014 instructions for the code reviewer agent:
+- Check naming conventions match project patterns
+- Verify error handling follows project style
+- Look for security issues (injection, XSS, auth bypass, secrets exposure)
+- Verify test coverage for changed code
+- Check import organization
+- Flag code duplication
+- Use the project's actual linter for automated checks
+
+### \`.claude/agents/test-writer.md\`
+
+YAML frontmatter:
+\`\`\`yaml
+---
+name: test-writer
+description: Generates comprehensive tests for code
+tools:
+  - Read
+  - Grep
+  - Glob
+  - Write
+  - Edit
+  - "Bash({test_command})"
+model: sonnet
+---
+\`\`\`
+
+Body content \u2014 instructions for the test writer agent:
+- Follow the AAA pattern (Arrange, Act, Assert)
+- Use the project's actual testing framework and syntax
+- Follow existing test file naming conventions
+- Include edge cases: empty inputs, nulls, errors, boundaries
+- Mock external dependencies following project patterns
+- Run tests after writing to verify they pass`;
+var RULES_PROMPT = `---
+
+## Phase 6: Generate Rules
+
+Write rule files to \`.claude/rules/\`. Each rule file needs YAML frontmatter.
+
+### Always Generate:
+
+**\`.claude/rules/code-style.md\`** (no \`paths\` \u2014 applies to all files)
+
+Content based on what was discovered in Phase 1:
+- Which formatter/linter to use and how (include actual commands)
+- Comment style: "why" not "what", keep comments current
+- Error handling patterns specific to this project
+- Git commit message conventions (conventional commits if commitlint is configured)
+- Import ordering conventions found in the codebase
+
+### Conditional Rules (generate ONLY if the language was detected):
+
+**TypeScript detected** \u2192 Write \`.claude/rules/typescript.md\`
+\`\`\`yaml
+---
+paths: ["**/*.ts", "**/*.tsx"]
+---
+\`\`\`
+Content: strict mode settings, type annotation preferences (interface vs type), import style (type imports), null handling, generic patterns found in the codebase.
+
+**Python detected** \u2192 Write \`.claude/rules/python.md\`
+\`\`\`yaml
+---
+paths: ["**/*.py"]
+---
+\`\`\`
+Content: type hint style, docstring format (Google/NumPy/Sphinx), import ordering (isort), virtual environment conventions, Python version requirements.
+
+**Swift detected** \u2192 Write \`.claude/rules/swift.md\`
+\`\`\`yaml
+---
+paths: ["**/*.swift"]
+---
+\`\`\`
+Content: access control patterns, optional handling, protocol-oriented patterns, SwiftLint rules if configured.
+
+**Go detected** \u2192 Write \`.claude/rules/go.md\`
+\`\`\`yaml
+---
+paths: ["**/*.go"]
+---
+\`\`\`
+Content: error handling patterns (wrap errors), interface placement, package naming, go fmt/vet/lint conventions.
+
+**Rust detected** \u2192 Write \`.claude/rules/rust.md\`
+\`\`\`yaml
+---
+paths: ["**/*.rs"]
+---
+\`\`\`
+Content: ownership/borrowing patterns, error handling (Result/Option, thiserror/anyhow), trait patterns, clippy lints.`;
+var COMMANDS_PROMPT = `---
+
+## Phase 7: Generate Commands
+
+Write 5 command files to \`.claude/commands/\`. Each needs YAML frontmatter with
+\`allowed-tools\`, \`description\`, and optionally \`argument-hint\`.
+
+### \`.claude/commands/task.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Write", "Edit", "Glob"]
+description: "Start or switch to a new task"
+argument-hint: "<task description>"
+---
+\`\`\`
+Body: Instructions to read current \`.claude/state/task.md\`, update status to "In Progress",
+record the task description and timestamp. If starting a new task, archive the previous one.
+
+### \`.claude/commands/status.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Glob", "Grep", "Bash(git status)", "Bash(git diff --stat)"]
+description: "Show current task and session state"
+---
+\`\`\`
+Body: Read \`.claude/state/task.md\`, show git status, list recently modified files,
+summarize current state in a concise format.
+
+### \`.claude/commands/done.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Write", "Edit", "Glob", "Grep", "Bash(git:*)", "Bash({test_command})", "Bash({lint_command})"]
+description: "Mark current task complete"
+---
+\`\`\`
+Body: Run tests and lint checks. If they pass, update \`.claude/state/task.md\`
+status to "Done". Show a summary of what was accomplished. Suggest next steps.
+
+### \`.claude/commands/analyze.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Glob", "Grep"]
+description: "Deep analysis of a specific area"
+argument-hint: "<area or file path>"
+---
+\`\`\`
+Body: Perform thorough analysis of the specified area. Read relevant files,
+trace data flow, identify patterns, document findings. Output a structured report.
+
+### \`.claude/commands/code-review.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Glob", "Grep", "Bash(git diff)", "Bash(git diff --cached)", "Bash({lint_command})"]
+description: "Review code changes for quality and security"
+---
+\`\`\`
+Body: Review staged and unstaged changes. Check for: naming consistency,
+error handling, security issues, test coverage, import organization,
+code duplication. Run the project's linter. Provide a summary with
+severity levels (critical, warning, suggestion).`;
 
 // src/cli.ts
 var __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
@@ -3938,11 +1338,12 @@ ${pc.bold("OPTIONS")}
 ${pc.bold("WHAT IT DOES")}
   1. Analyzes your repository's tech stack
   2. Launches Claude CLI to deeply analyze your codebase
-  3. Generates tailored Claude Code configurations:
+  3. Generates all .claude/ configuration files:
      - CLAUDE.md with project-specific instructions (via Claude analysis)
-     - Skills for your frameworks (Next.js, FastAPI, etc.)
+     - Skills for your frameworks and workflows
      - Agents for code review and testing
      - Rules matching your code style
+     - Commands for task management
 
 ${pc.bold("REQUIREMENTS")}
   Claude CLI must be installed: https://claude.ai/download
@@ -3995,70 +1396,277 @@ function showTechStack(projectInfo, verbose) {
   }
   console.log();
 }
+var frameworkChoices = {
+  typescript: [
+    { title: "Next.js", value: "nextjs" },
+    { title: "React", value: "react" },
+    { title: "Vue", value: "vue" },
+    { title: "Svelte", value: "svelte" },
+    { title: "Express", value: "express" },
+    { title: "NestJS", value: "nestjs" },
+    { title: "Fastify", value: "fastify" },
+    { title: "Hono", value: "hono" },
+    { title: "Astro", value: "astro" },
+    { title: "None / Other", value: null }
+  ],
+  javascript: [
+    { title: "Next.js", value: "nextjs" },
+    { title: "React", value: "react" },
+    { title: "Vue", value: "vue" },
+    { title: "Svelte", value: "svelte" },
+    { title: "Express", value: "express" },
+    { title: "NestJS", value: "nestjs" },
+    { title: "Fastify", value: "fastify" },
+    { title: "Hono", value: "hono" },
+    { title: "Astro", value: "astro" },
+    { title: "None / Other", value: null }
+  ],
+  python: [
+    { title: "FastAPI", value: "fastapi" },
+    { title: "Django", value: "django" },
+    { title: "Flask", value: "flask" },
+    { title: "None / Other", value: null }
+  ],
+  go: [
+    { title: "Gin", value: "gin" },
+    { title: "Echo", value: "echo" },
+    { title: "Fiber", value: "fiber" },
+    { title: "None / Other", value: null }
+  ],
+  swift: [
+    { title: "SwiftUI", value: "swiftui" },
+    { title: "UIKit", value: "uikit" },
+    { title: "Vapor", value: "vapor" },
+    { title: "None / Other", value: null }
+  ],
+  kotlin: [
+    { title: "Jetpack Compose", value: "jetpack-compose" },
+    { title: "Android Views", value: "android-views" },
+    { title: "Spring", value: "spring" },
+    { title: "None / Other", value: null }
+  ],
+  java: [
+    { title: "Spring", value: "spring" },
+    { title: "Quarkus", value: "quarkus" },
+    { title: "None / Other", value: null }
+  ],
+  ruby: [
+    { title: "Rails", value: "rails" },
+    { title: "Sinatra", value: "sinatra" },
+    { title: "None / Other", value: null }
+  ],
+  rust: [
+    { title: "Actix", value: "actix" },
+    { title: "Axum", value: "axum" },
+    { title: "Rocket", value: "rocket" },
+    { title: "None / Other", value: null }
+  ]
+};
+var defaultFrameworkChoices = [{ title: "None / Other", value: null }];
 async function promptNewProject(args) {
   if (!args.interactive) {
     return null;
   }
   console.log(pc.yellow("New project detected - let's set it up!"));
   console.log();
-  const response = await prompts([
-    {
-      type: "text",
-      name: "description",
-      message: "What are you building?",
-      initial: "A new project"
-    },
-    {
-      type: "select",
-      name: "primaryLanguage",
-      message: "Primary language?",
-      choices: [
-        { title: "TypeScript", value: "typescript" },
-        { title: "JavaScript", value: "javascript" },
-        { title: "Python", value: "python" },
-        { title: "Go", value: "go" },
-        { title: "Rust", value: "rust" },
-        { title: "Other", value: null }
-      ]
-    },
-    {
-      type: (prev) => prev === "typescript" || prev === "javascript" ? "select" : null,
-      name: "framework",
-      message: "Framework?",
-      choices: [
-        { title: "Next.js", value: "nextjs" },
-        { title: "React", value: "react" },
-        { title: "Vue", value: "vue" },
-        { title: "Svelte", value: "svelte" },
-        { title: "Express", value: "express" },
-        { title: "NestJS", value: "nestjs" },
-        { title: "Hono", value: "hono" },
-        { title: "None / Other", value: null }
-      ]
-    },
-    {
-      type: (_, values) => values.primaryLanguage === "python" ? "select" : null,
-      name: "framework",
-      message: "Framework?",
-      choices: [
-        { title: "FastAPI", value: "fastapi" },
-        { title: "Django", value: "django" },
-        { title: "Flask", value: "flask" },
-        { title: "None / Other", value: null }
-      ]
-    }
-  ]);
-  if (!response.description) {
+  const descResponse = await prompts({
+    type: "text",
+    name: "description",
+    message: "What are you building?",
+    initial: "A new project"
+  });
+  if (!descResponse.description) {
     return null;
   }
+  const langResponse = await prompts({
+    type: "select",
+    name: "primaryLanguage",
+    message: "Primary language?",
+    choices: [
+      { title: "TypeScript", value: "typescript" },
+      { title: "JavaScript", value: "javascript" },
+      { title: "Python", value: "python" },
+      { title: "Go", value: "go" },
+      { title: "Rust", value: "rust" },
+      { title: "Swift", value: "swift" },
+      { title: "Kotlin", value: "kotlin" },
+      { title: "Java", value: "java" },
+      { title: "Ruby", value: "ruby" },
+      { title: "C#", value: "csharp" },
+      { title: "PHP", value: "php" },
+      { title: "C++", value: "cpp" }
+    ]
+  });
+  const lang = langResponse.primaryLanguage || "typescript";
+  const fwChoices = frameworkChoices[lang] || defaultFrameworkChoices;
+  const fwResponse = await prompts({
+    type: "select",
+    name: "framework",
+    message: "Framework?",
+    choices: fwChoices
+  });
+  const pmChoices = getPackageManagerChoices(lang);
+  const pmResponse = await prompts({
+    type: "select",
+    name: "packageManager",
+    message: "Package manager?",
+    choices: pmChoices
+  });
+  const testChoices = getTestingFrameworkChoices(lang);
+  const testResponse = await prompts({
+    type: "select",
+    name: "testingFramework",
+    message: "Testing framework?",
+    choices: testChoices
+  });
+  const lintChoices = getLinterFormatterChoices(lang);
+  const lintResponse = await prompts({
+    type: "select",
+    name: "linter",
+    message: "Linter/Formatter?",
+    choices: lintChoices
+  });
+  const typeResponse = await prompts({
+    type: "select",
+    name: "projectType",
+    message: "Project type?",
+    choices: [
+      { title: "Web App", value: "Web App" },
+      { title: "API / Backend", value: "API/Backend" },
+      { title: "CLI Tool", value: "CLI Tool" },
+      { title: "Library / Package", value: "Library/Package" },
+      { title: "Mobile App", value: "Mobile App" },
+      { title: "Desktop App", value: "Desktop App" },
+      { title: "Monorepo", value: "Monorepo" },
+      { title: "Other", value: "Other" }
+    ]
+  });
   return {
-    description: response.description,
-    primaryLanguage: response.primaryLanguage || "typescript",
-    framework: response.framework || null,
+    description: descResponse.description,
+    primaryLanguage: langResponse.primaryLanguage || "typescript",
+    framework: fwResponse.framework || null,
     includeTests: true,
-    includeLinting: true
+    includeLinting: true,
+    packageManager: pmResponse.packageManager || null,
+    testingFramework: testResponse.testingFramework || null,
+    linter: lintResponse.linter || null,
+    formatter: lintResponse.linter || null,
+    // Use same as linter for simplicity
+    projectType: typeResponse.projectType || "Other"
   };
 }
+function getPackageManagerChoices(lang) {
+  if (lang === "typescript" || lang === "javascript") {
+    return [
+      { title: "npm", value: "npm" },
+      { title: "yarn", value: "yarn" },
+      { title: "pnpm", value: "pnpm" },
+      { title: "bun", value: "bun" }
+    ];
+  }
+  if (lang === "python") {
+    return [
+      { title: "pip", value: "pip" },
+      { title: "poetry", value: "poetry" }
+    ];
+  }
+  if (lang === "rust") {
+    return [{ title: "cargo", value: "cargo" }];
+  }
+  if (lang === "go") {
+    return [{ title: "go modules", value: "go" }];
+  }
+  if (lang === "ruby") {
+    return [{ title: "bundler", value: "bundler" }];
+  }
+  if (lang === "java" || lang === "kotlin") {
+    return [
+      { title: "Maven", value: "maven" },
+      { title: "Gradle", value: "gradle" }
+    ];
+  }
+  return [{ title: "None / Default", value: null }];
+}
+function getTestingFrameworkChoices(lang) {
+  if (lang === "typescript" || lang === "javascript") {
+    return [
+      { title: "Vitest", value: "vitest" },
+      { title: "Jest", value: "jest" },
+      { title: "Bun Test", value: "bun-test" },
+      { title: "Playwright", value: "playwright" },
+      { title: "None / I'll set it up later", value: null }
+    ];
+  }
+  if (lang === "python") {
+    return [
+      { title: "pytest", value: "pytest" },
+      { title: "unittest", value: "unittest" },
+      { title: "None / I'll set it up later", value: null }
+    ];
+  }
+  if (lang === "go") {
+    return [
+      { title: "go test", value: "go-test" },
+      { title: "None / I'll set it up later", value: null }
+    ];
+  }
+  if (lang === "rust") {
+    return [
+      { title: "cargo test", value: "rust-test" },
+      { title: "None / I'll set it up later", value: null }
+    ];
+  }
+  if (lang === "ruby") {
+    return [
+      { title: "RSpec", value: "rspec" },
+      { title: "None / I'll set it up later", value: null }
+    ];
+  }
+  if (lang === "java" || lang === "kotlin") {
+    return [
+      { title: "JUnit", value: "junit" },
+      { title: "None / I'll set it up later", value: null }
+    ];
+  }
+  return [{ title: "None / I'll set it up later", value: null }];
+}
+function getLinterFormatterChoices(lang) {
+  if (lang === "typescript" || lang === "javascript") {
+    return [
+      { title: "Biome", value: "biome" },
+      { title: "ESLint + Prettier", value: "eslint" },
+      { title: "ESLint", value: "eslint" },
+      { title: "None", value: null }
+    ];
+  }
+  if (lang === "python") {
+    return [
+      { title: "Ruff", value: "ruff" },
+      { title: "Flake8 + Black", value: "flake8" },
+      { title: "Pylint", value: "pylint" },
+      { title: "None", value: null }
+    ];
+  }
+  if (lang === "go") {
+    return [
+      { title: "golangci-lint", value: "golangci-lint" },
+      { title: "None", value: null }
+    ];
+  }
+  if (lang === "rust") {
+    return [
+      { title: "Clippy", value: "clippy" },
+      { title: "None", value: null }
+    ];
+  }
+  if (lang === "ruby") {
+    return [
+      { title: "RuboCop", value: "rubocop" },
+      { title: "None", value: null }
+    ];
+  }
+  return [{ title: "None", value: null }];
+}
 function createTaskFile(projectInfo, preferences) {
   const taskPath = path3.join(projectInfo.rootDir, ".claude", "state", "task.md");
   fs3.mkdirSync(path3.dirname(taskPath), { recursive: true });
@@ -4189,25 +1797,33 @@ function runClaudeAnalysis(projectDir, projectInfo) {
   return new Promise((resolve) => {
     const prompt = getAnalysisPrompt(projectInfo);
     console.log(pc.cyan("Launching Claude for deep project analysis..."));
-    console.log(pc.gray("Claude will read your codebase and generate a comprehensive CLAUDE.md"));
+    console.log(
+      pc.gray("Claude will read your codebase and generate all .claude/ configuration files")
+    );
     console.log();
     const child = spawn(
       "claude",
       [
         "-p",
-        prompt,
+        "--dangerously-skip-permissions",
         "--allowedTools",
         "Read",
+        "--allowedTools",
         "Glob",
+        "--allowedTools",
         "Grep",
-        `Write(.claude/**)`,
-        `Edit(.claude/**)`
+        "--allowedTools",
+        "Write",
+        "--allowedTools",
+        "Edit"
       ],
       {
         cwd: projectDir,
-        stdio: ["ignore", "inherit", "inherit"]
+        stdio: ["pipe", "inherit", "inherit"]
       }
     );
+    child.stdin.write(prompt);
+    child.stdin.end();
     child.on("error", (err) => {
       console.error(pc.red(`Failed to launch Claude CLI: ${err.message}`));
       resolve(false);
@@ -4224,6 +1840,24 @@ function runClaudeAnalysis(projectDir, projectInfo) {
     });
   });
 }
+function getGeneratedFiles(projectDir) {
+  const claudeDir = path3.join(projectDir, ".claude");
+  const files = [];
+  function walk(dir) {
+    if (!fs3.existsSync(dir)) return;
+    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else {
+        files.push(path3.relative(projectDir, fullPath));
+      }
+    }
+  }
+  walk(claudeDir);
+  return files;
+}
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.help) {
@@ -4249,6 +1883,18 @@ async function main() {
         projectInfo.techStack.primaryFramework = preferences.framework;
         projectInfo.techStack.frameworks = [preferences.framework];
       }
+      if (preferences.packageManager) {
+        projectInfo.techStack.packageManager = preferences.packageManager;
+      }
+      if (preferences.testingFramework) {
+        projectInfo.techStack.testingFramework = preferences.testingFramework;
+      }
+      if (preferences.linter) {
+        projectInfo.techStack.linter = preferences.linter;
+      }
+      if (preferences.formatter) {
+        projectInfo.techStack.formatter = preferences.formatter;
+      }
       projectInfo.description = preferences.description;
     }
   } else {
@@ -4277,28 +1923,12 @@ async function main() {
     console.error(pc.gray("Install it from: https://claude.ai/download"));
     process.exit(1);
   }
-  console.log(pc.gray("Generating supporting configuration..."));
+  console.log(pc.gray("Setting up .claude/ directory structure..."));
   console.log();
-  const result = generateArtifacts(projectInfo);
-  const { created, updated, skipped } = writeArtifacts(result.artifacts, projectDir, args.force);
-  if (created.length > 0) {
-    console.log(pc.green("Created:"));
-    for (const file of created) {
-      console.log(pc.green(`  + ${file}`));
-    }
-  }
-  if (updated.length > 0) {
-    console.log(pc.blue("Updated:"));
-    for (const file of updated) {
-      console.log(pc.blue(`  ~ ${file}`));
-    }
-  }
-  if (skipped.length > 0 && args.verbose) {
-    console.log(pc.gray("Preserved:"));
-    for (const file of skipped) {
-      console.log(pc.gray(`  - ${file}`));
-    }
-  }
+  writeSettings(projectDir, projectInfo.techStack);
+  ensureDirectories(projectDir);
+  console.log(pc.green("Created:"));
+  console.log(pc.green("  + .claude/settings.json"));
   console.log();
   createTaskFile(projectInfo, preferences);
   const success = await runClaudeAnalysis(projectDir, projectInfo);
@@ -4306,44 +1936,55 @@ async function main() {
     console.error(pc.red("Claude analysis failed. Please try again."));
     process.exit(1);
   }
-  const totalFiles = created.length + updated.length + 1;
+  const generatedFiles = getGeneratedFiles(projectDir);
   console.log();
-  console.log(pc.green(`Done! (${totalFiles} files)`));
+  console.log(pc.green(`Done! (${generatedFiles.length} files)`));
   console.log();
   console.log(pc.bold("Generated for your stack:"));
-  console.log(pc.cyan("  CLAUDE.md (deep analysis by Claude)"));
-  const skills = result.artifacts.filter((a) => a.type === "skill");
-  const agents = result.artifacts.filter((a) => a.type === "agent");
-  const rules = result.artifacts.filter((a) => a.type === "rule");
+  const skills = generatedFiles.filter((f) => f.includes("/skills/"));
+  const agents = generatedFiles.filter((f) => f.includes("/agents/"));
+  const rules = generatedFiles.filter((f) => f.includes("/rules/"));
+  const commands = generatedFiles.filter((f) => f.includes("/commands/"));
+  if (generatedFiles.some((f) => f.endsWith("CLAUDE.md"))) {
+    console.log(pc.cyan("  CLAUDE.md (deep analysis by Claude)"));
+  }
   if (skills.length > 0) {
     console.log(
-      `  ${skills.length} skills (${skills.map((s) => path3.basename(s.path, ".md")).join(", ")})`
+      `  ${skills.length} skills (${skills.map((s) => path3.basename(s, ".md")).join(", ")})`
     );
   }
   if (agents.length > 0) {
     console.log(
-      `  ${agents.length} agents (${agents.map((a) => path3.basename(a.path, ".md")).join(", ")})`
+      `  ${agents.length} agents (${agents.map((a) => path3.basename(a, ".md")).join(", ")})`
     );
   }
   if (rules.length > 0) {
     console.log(`  ${rules.length} rules`);
   }
+  if (commands.length > 0) {
+    console.log(`  ${commands.length} commands`);
+  }
   console.log();
   console.log(`${pc.cyan("Next step:")} Run ${pc.bold("claude")} to start working!`);
   console.log();
   console.log(
-    pc.gray("Your CLAUDE.md was generated by deep analysis - review it with: cat .claude/CLAUDE.md")
+    pc.gray(
+      "Your .claude/ files were generated by deep analysis - review them with: ls -la .claude/"
+    )
   );
 }
-var isMain = fs3.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
-if (isMain) {
-  main().catch((err) => {
-    console.error(pc.red("Error:"), err.message);
-    if (process.env.DEBUG) {
-      console.error(err.stack);
-    }
-    process.exit(1);
-  });
+try {
+  const isMain = process.argv[1] && fs3.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  if (isMain) {
+    main().catch((err) => {
+      console.error(pc.red("Error:"), err.message);
+      if (process.env.DEBUG) {
+        console.error(err.stack);
+      }
+      process.exit(1);
+    });
+  }
+} catch {
 }
 export {
   checkClaudeCli,