# Establish canonical reference worktree
cd ~/projects/application
git worktree add ../application-reference main

# Create AI-assisted development worktree
git worktree add -b ai-feature-implementation ../application-ai

# Configure Claude Code context inheritance
cd ../application-ai

{
  "contextSources": [
    {
      "type": "referenceCodebase",
      "path": "../application-reference",
      "purpose": "architectural patterns and style guidelines",
      "includePatterns": [
        "src/core/**/*.ts",
        "src/services/**/*.ts",
        "docs/architecture/**/*.md"
      ],
      "excludePatterns": ["**/test/**", "**/*.spec.ts"]
    },
    {
      "type": "experimentalWorkspace",
      "path": ".",
      "purpose": "active development with AI assistance"
    }
  ],
  "codingStandards": {
    "enforceTypeScript": true,
    "requireTests": true,
    "minimumCoverage": 80,
    "architecturalConstraints": [
      "No direct database access in UI components",
      "All API calls through service layer",
      "Pure functions for business logic"
    ]
  }
}

# Within AI worktree, invoke with explicit context boundaries
claude-code generate \
  --context-from ../application-reference/src/services/UserService.ts \
  --task "Implement AdminUserService following established patterns" \
  --constraints "Match UserService architecture, add audit logging" \
  --test-requirements "Unit tests with 85%+ coverage"

# Stage 1: Initial AI generation (highly permissive)
git worktree add -b ai-stage1-generation ../app-ai-generate
cd ../app-ai-generate

# Configure Claude Code for exploratory generation
claude-code config set --exploration-mode aggressive
claude-code generate "Implement OAuth2 authentication flow with refresh tokens"

# Stage 2: Human review and refinement
git worktree add -b ai-stage2-review ../app-ai-review
cd ../app-ai-review
git cherry-pick ai-stage1-generation

# Manually review, refactor, add tests
# Claude Code now assists with refinement, not generation
claude-code refactor --focus "error handling and edge cases"

# Stage 3: Integration testing
git worktree add -b ai-stage3-integration ../app-ai-integration
cd ../app-ai-integration
git merge ai-stage2-review

# Run comprehensive test suites
npm run test:integration
npm run test:e2e

# Stage 4: Final integration to main (only if all gates pass)
cd ~/projects/application
git merge --no-ff ai-stage3-integration
git worktree remove ../app-ai-generate
git worktree remove ../app-ai-review
git worktree remove ../app-ai-integration

# Spawn three parallel exploration worktrees
git worktree add -b ai-redis-cache ../app-redis-exploration
git worktree add -b ai-memory-cache ../app-memory-exploration
git worktree add -b ai-hybrid-cache ../app-hybrid-exploration

# Redis approach
cd ../app-redis-exploration
claude-code generate \
  --task "Implement Redis-backed caching layer" \
  --requirements "Handle connection failures, implement cache invalidation"

# In-memory approach
cd ../app-memory-exploration
claude-code generate \
  --task "Implement in-memory caching with LRU eviction" \
  --requirements "Thread-safe, configurable size limits"

# Hybrid approach
cd ../app-hybrid-exploration
claude-code generate \
  --task "Implement two-tier cache: in-memory L1, Redis L2" \
  --requirements "Automatic promotion/demotion, consistency guarantees"

git worktree add ../app-cache-benchmark main

# Create benchmark suite
cat > ../app-cache-benchmark/benchmark-cache.js << 'EOF'
const { performance } = require('perf_hooks');

async function benchmarkImplementation(cachePath) {
  const Cache = require(cachePath);
  const cache = new Cache();

  // Benchmark: Write Performance
  const writeStart = performance.now();
  for (let i = 0; i < 10000; i++) {
    await cache.set(`key${i}`, { data: `value${i}` });
  }
  const writeTime = performance.now() - writeStart;

  // Benchmark: Read Performance
  const readStart = performance.now();
  for (let i = 0; i < 10000; i++) {
    await cache.get(`key${i}`);
  }
  const readTime = performance.now() - readStart;

  // Benchmark: Memory Usage
  const memUsage = process.memoryUsage().heapUsed / 1024 / 1024;

  return { writeTime, readTime, memUsage };
}

// Test each implementation
(async () => {
  console.log('Redis:', await benchmarkImplementation('../app-redis-exploration/src/cache'));
  console.log('Memory:', await benchmarkImplementation('../app-memory-exploration/src/cache'));
  console.log('Hybrid:', await benchmarkImplementation('../app-hybrid-exploration/src/cache'));
})();
EOF

cd ~/projects/application
git merge --no-ff ai-hybrid-cache
git worktree remove ../app-redis-exploration
git worktree remove ../app-memory-exploration
git worktree remove ../app-hybrid-exploration
git worktree remove ../app-cache-benchmark

{
  "folders": [
    {
      "name": "Main (Production)",
      "path": "~/projects/application"
    },
    {
      "name": "AI Experimentation",
      "path": "~/projects/application-ai"
    },
    {
      "name": "Reference Architecture",
      "path": "~/projects/application-reference"
    }
  ],
  "settings": {
    "git.autorefresh": true,
    "git.enableSmartCommit": false,
    "git.confirmSync": true,

    // Worktree-specific linting rules
    "[application-ai]": {
      "editor.formatOnSave": true,
      "eslint.enable": true,
      "eslint.run": "onSave"
    },

    // Reference worktree is read-only
    "[application-reference]": {
      "editor.readOnly": true
    },

    // AI tool settings
    "github.copilot.enable": {
      "*": false,
      "application-ai": true
    }
  },
  "extensions": {
    "recommendations": [
      "eamodio.gitlens",
      "github.copilot",
      "dbaeumer.vscode-eslint"
    ]
  }
}

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Debug Main Worktree",
      "cwd": "${workspaceFolder:Main (Production)}",
      "program": "${workspaceFolder:Main (Production)}/src/index.js"
    },
    {
      "type": "node",
      "request": "launch",
      "name": "Debug AI Worktree",
      "cwd": "${workspaceFolder:AI Experimentation}",
      "program": "${workspaceFolder:AI Experimentation}/src/index.js",
      "env": {
        "NODE_ENV": "development",
        "DEBUG": "ai:*"
      }
    }
  ],
  "compounds": [
    {
      "name": "Compare Main vs AI",
      "configurations": ["Debug Main Worktree", "Debug AI Worktree"]
    }
  ]
}

# Main worktree project
cd ~/projects/application
idea .

# AI worktree project (inherits run configurations)
cd ~/projects/application-ai
idea . --wait

# Link shared configurations
ln -s ../application/.idea/codeStyles ../application-ai/.idea/codeStyles
ln -s ../application/.idea/inspectionProfiles ../application-ai/.idea/inspectionProfiles

<!-- AI_Development_Server.xml -->
<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="AI Development Server" type="NodeJSConfigurationType">
    <option name="workingDirectory" value="$PROJECT_DIR$/../application-ai" />
    <option name="envs">
      <env name="NODE_ENV" value="development" />
      <env name="AI_ASSISTED" value="true" />
    </option>
    <option name="path-to-node" value="$USER_HOME$/.nvm/versions/node/v20.0.0/bin/node" />
    <option name="path-to-js-file" value="src/index.js" />
    <option name="application-parameters" value="--experimental-mode" />
  </configuration>
</component>

# Without optimization
du -sh */node_modules
# Output:
# 450M    application/node_modules
# 450M    application-ai/node_modules
# 450M    application-reference/node_modules
# Total: 1.35GB for identical dependencies

# Install pnpm globally
npm install -g pnpm

# Configure pnpm store location (shared across worktrees)
pnpm config set store-dir ~/.pnpm-store

# In each worktree, use pnpm instead of npm
cd ~/projects/application
pnpm install

cd ~/projects/application-ai
pnpm install  # Reuses packages from ~/.pnpm-store

cd ~/projects/application-reference
pnpm install  # Minimal new downloads

du -sh ~/.pnpm-store
# Output: 480M (single copy of all packages)

du -sh */node_modules
# Output (hard links, not actual storage):
# 45M     application/node_modules
# 45M     application-ai/node_modules
# 45M     application-reference/node_modules
# Actual total: ~525MB (vs 1.35GB)

# Create workspace root
mkdir -p ~/projects/application-workspace
cd ~/projects/application-workspace

# Configure workspace
cat > package.json << 'EOF'
{
  "private": true,
  "workspaces": [
    "../application",
    "../application-ai",
    "../application-reference"
  ]
}
EOF

# Install once, shared across all worktrees
yarn install

# GitHub Copilot: Disable in specific worktrees
cd ~/projects/application-reference
echo '{ "github.copilot.enable": false }' > .vscode/settings.json

# Claude Code: Restrict context scope
cd ~/projects/application
claude-code config set context.scope "workspace-only"
claude-code config set context.exclude "[\"../application-ai\", \"../app-*\"]"

#!/bin/bash
# Script: ai-worktree-lifecycle.sh
# Purpose: Automate creation, AI population, and evaluation of experimental worktrees

set -euo pipefail

# Configuration
MAIN_WORKTREE="${HOME}/projects/application"
AI_WORKTREE_PREFIX="application-ai"
CLAUDE_CODE_AVAILABLE=$(command -v claude-code &> /dev/null && echo "true" || echo "false")

# Function: Create AI-assisted worktree
create_ai_worktree() {
    local feature_name="$1"
    local ai_prompt="$2"
    local worktree_path="${MAIN_WORKTREE}-ai-${feature_name}"

    echo "Creating AI worktree for: ${feature_name}"

    # Create worktree from main
    cd "${MAIN_WORKTREE}"
    git worktree add -b "ai/${feature_name}" "${worktree_path}"

    # Configure worktree for AI assistance
    cd "${worktree_path}"

    # Install dependencies (using pnpm for efficiency)
    if command -v pnpm &> /dev/null; then
        pnpm install
    else
        npm install
    fi

    # Initialize AI context
    mkdir -p .ai-context
    cat > .ai-context/feature-spec.md << EOF
# Feature: ${feature_name}

## Requirements
${ai_prompt}

## Constraints
- Follow existing architecture patterns in ${MAIN_WORKTREE}
- Maintain minimum 80% test coverage
- No breaking changes to public APIs

## Success Criteria
- All tests pass
- Linting passes with zero errors
- Manual code review approved
EOF

    # Invoke Claude Code if available
    if [[ "${CLAUDE_CODE_AVAILABLE}" == "true" ]]; then
        echo "Invoking Claude Code for initial implementation..."
        claude-code generate \
            --context .ai-context/feature-spec.md \
            --output src/features/"${feature_name}" \
            --test-output tests/features/"${feature_name}"

        # Run initial validation
        npm run test
        npm run lint
    else
        echo "⚠️  Claude Code not available. Manual implementation required."
    fi

    echo "✅ AI worktree created: ${worktree_path}"
    echo "Next steps:"
    echo "  1. cd ${worktree_path}"
    echo "  2. Review AI-generated code"
    echo "  3. Run: npm test && npm run lint"
    echo "  4. Commit changes if acceptable"
    echo "  5. Merge to main: cd ${MAIN_WORKTREE} && git merge ai/${feature_name}"
}

# Function: Evaluate AI worktree quality
evaluate_ai_worktree() {
    local worktree_path="$1"

    cd "${worktree_path}"

    echo "Evaluating worktree: ${worktree_path}"

    # Run quality gates
    local lint_status=0
    local test_status=0
    local coverage_status=0

    npm run lint || lint_status=$?
    npm run test || test_status=$?
    npm run test:coverage || coverage_status=$?

    # Parse coverage (example: assumes istanbul/nyc output)
    local coverage=$(grep -oP 'Statements.*\K\d+(?=%)' coverage/coverage-summary.json 2>/dev/null || echo "0")

    # Generate quality report
    cat > AI_EVALUATION_REPORT.md << EOF
# AI-Generated Code Evaluation Report

**Worktree**: ${worktree_path}
**Evaluation Date**: $(date -Iseconds)

## Quality Metrics

- **Linting**: $([ $lint_status -eq 0 ] && echo "✅ PASS" || echo "❌ FAIL")
- **Tests**: $([ $test_status -eq 0 ] && echo "✅ PASS" || echo "❌ FAIL")
- **Coverage**: ${coverage}% $([ $coverage -ge 80 ] && echo "✅ PASS" || echo "❌ FAIL (minimum 80%)")

## Recommendation

$(if [ $lint_status -eq 0 ] && [ $test_status -eq 0 ] && [ $coverage -ge 80 ]; then
    echo "✅ **APPROVED FOR INTEGRATION** - All quality gates passed"
else
    echo "❌ **REQUIRES REFINEMENT** - Quality gates not met"
fi)

## Next Steps

$(if [ $lint_status -eq 0 ] && [ $test_status -eq 0 ] && [ $coverage -ge 80 ]; then
    echo "- Conduct manual code review"
    echo "- Merge to main: \`git merge --no-ff $(basename ${worktree_path})\`"
    echo "- Clean up worktree: \`git worktree remove ${worktree_path}\`"
else
    echo "- Address linting/test failures"
    echo "- Improve test coverage to ≥80%"
    echo "- Re-run evaluation"
fi)
EOF

    cat AI_EVALUATION_REPORT.md
}

# Function: Cleanup stale AI worktrees
cleanup_ai_worktrees() {
    echo "Cleaning up stale AI worktrees..."

    cd "${MAIN_WORKTREE}"
    git worktree list | grep "${AI_WORKTREE_PREFIX}" | awk '{print $1}' | while read -r worktree; do
        # Check if worktree has uncommitted changes
        if git -C "${worktree}" diff-index --quiet HEAD --; then
            echo "Removing clean worktree: ${worktree}"
            git worktree remove "${worktree}"
        else
            echo "Skipping worktree with uncommitted changes: ${worktree}"
        fi
    done

    # Prune orphaned references
    git worktree prune -v
}

# Main CLI interface
case "${1:-}" in
    create)
        create_ai_worktree "${2}" "${3}"
        ;;
    evaluate)
        evaluate_ai_worktree "${2}"
        ;;
    cleanup)
        cleanup_ai_worktrees
        ;;
    *)
        echo "Usage: $0 {create|evaluate|cleanup}"
        echo ""
        echo "Commands:"
        echo "  create <feature-name> <ai-prompt>   Create AI-assisted worktree"
        echo "  evaluate <worktree-path>            Evaluate AI-generated code quality"
        echo "  cleanup                             Remove stale AI worktrees"
        exit 1
        ;;
esac

# Create AI-assisted worktree for authentication feature
./ai-worktree-lifecycle.sh create \
    "oauth2-authentication" \
    "Implement OAuth2 authentication with refresh token rotation and PKCE"

# Evaluate generated code
./ai-worktree-lifecycle.sh evaluate ../application-ai-oauth2-authentication

# Cleanup all completed AI worktrees
./ai-worktree-lifecycle.sh cleanup

# Create global gitignore for AI worktrees
cat > ~/.gitignore_ai_worktrees << 'EOF'
# Credentials
*.key
*.pem
*.p12
.env
.env.*
secrets.json
credentials.yaml

# AI-specific temporary files
.ai-context/**/*.secret
.claude-temp/**
**/ai-experiments/**/*.key
EOF

# Configure in all AI worktrees
cd ~/projects/application-ai
git config core.excludesFile ~/.gitignore_ai_worktrees

# .git/hooks/pre-commit (in AI worktrees)
#!/bin/bash
if git diff --cached --name-only | grep -qE '\.(key|pem|env)$'; then
    echo "❌ ERROR: Attempting to commit credential file"
    echo "Detected files:"
    git diff --cached --name-only | grep -E '\.(key|pem|env)$'
    exit 1
fi

# Install security scanning tools
npm install --save-dev @npmcli/arborist snyk eslint-plugin-security

# Configure automated scanning
cat > .github/workflows/ai-worktree-security.yml << 'EOF'
name: AI Worktree Security Scan

on:
  push:
    branches:
      - 'ai/**'

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm ci

      - name: Run Snyk security scan
        run: npx snyk test --severity-threshold=high

      - name: Run ESLint security plugin
        run: npx eslint --plugin security .

      - name: Check for hardcoded secrets
        run: |
          if grep -r "api_key\|password\|secret" src/ | grep -v "placeholder"; then
            echo "❌ Potential hardcoded secrets detected"
            exit 1
          fi
EOF

# Configure shared build cache
mkdir -p ~/.cache/ai-worktrees/{babel,eslint,jest,webpack}

# In each worktree, configure tools to use shared cache
cat > .babelrc.js << 'EOF'
module.exports = {
  presets: ['@babel/preset-env'],
  cacheDirectory: process.env.HOME + '/.cache/ai-worktrees/babel'
};
EOF

# ESLint shared cache
echo '{ "cache": true, "cacheLocation": "~/.cache/ai-worktrees/eslint" }' > .eslintrc.json

# Jest shared cache
cat > jest.config.js << 'EOF'
module.exports = {
  cacheDirectory: process.env.HOME + '/.cache/ai-worktrees/jest'
};
EOF

# Restrict AI context to current worktree only
cd ~/projects/application

# For Claude Code
claude-code config set context.scope "workspace-only"
claude-code config set context.exclude "[\"../application-*\"]"

# For GitHub Copilot (VS Code)
code --user-data-dir ~/.vscode-main  # Use separate VS Code instance per worktree

# After AI code generation, sync package-lock
cd ~/projects/application-ai
cp ../application/package-lock.json .
npm ci  # Reinstall with locked versions

# Verify no version drift
diff package.json ../application/package.json

# Create .claude-context manifest (curated files only)
cat > .claude-context.json << 'EOF'
{
  "include": [
    "src/core/**/*.ts",
    "src/services/AuthService.ts",
    "docs/architecture.md"
  ],
  "exclude": [
    "**/*.test.ts",
    "**/node_modules/**",
    "../application-*/**"
  ],
  "maxTokens": 100000
}
EOF

claude-code config set context.manifest ".claude-context.json"