feat: Add Redis integration with environment-aware key prefixing

- Add ioredis client with graceful fallback to in-memory storage
- Implement environment-aware key prefixing (prod:/preview:/dev:)
- Add debug wizard resolve and stats API routes
- Update analyze route to use Redis for pattern correlation
- Update SBAR wizard to use Redis for session storage
- Add build:vercel script to skip mkdocs build on Vercel

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: 2 people

website/app/api/debug-wizard/analyze/route.ts

@@ -28,6 +28,12 @@ import {
   validateFilesForTier,
 } from '@/lib/debug-wizard/tiers';
 
+import {
+  findSimilarPatterns,
+  isRedisAvailable,
+  type StoredBugPattern,
+} from '@/lib/redis';
+
 // ============================================================================
 // Error Pattern Classifiers (mirrors Python wizard)
 // ============================================================================
@@ -219,17 +225,70 @@ function getFileExtension(filePath: string): string {
   return parts.length > 1 ? `.${parts[parts.length - 1]}` : 'unknown';
 }
 
+/**
+ * Convert stored Redis pattern to HistoricalMatch format
+ */
+function convertToHistoricalMatch(
+  pattern: StoredBugPattern,
+  errorType: ErrorType,
+  fileExt: string
+): HistoricalMatch {
+  const matchingFactors: string[] = [];
+  let similarityScore = 0.5; // Base score
+
+  // Boost for same error type
+  if (pattern.error_type === errorType) {
+    similarityScore += 0.3;
+    matchingFactors.push(`Same error type: ${pattern.error_type}`);
+  }
+
+  // Boost for same file type
+  if (pattern.file_type === fileExt) {
+    similarityScore += 0.15;
+    matchingFactors.push(`Same file type: ${fileExt}`);
+  }
+
+  return {
+    date: pattern.date,
+    file: pattern.file_path,
+    error_type: pattern.error_type as ErrorType,
+    root_cause: pattern.root_cause,
+    fix_applied: pattern.fix_applied,
+    fix_code: pattern.fix_code,
+    resolution_time_minutes: pattern.resolution_time_minutes,
+    similarity_score: Math.min(similarityScore, 1.0),
+    matching_factors: matchingFactors,
+  };
+}
+
 /**
  * Find matching historical patterns based on error
+ * Uses Redis when available, falls back to demo patterns
  */
-function findHistoricalMatches(
+async function findHistoricalMatches(
   errorType: ErrorType,
   filePath: string,
   maxMatches: number
-): HistoricalMatch[] {
+): Promise<HistoricalMatch[]> {
   const fileExt = getFileExtension(filePath);
 
-  // Filter and adjust similarity scores based on current error
+  // Try Redis first
+  if (isRedisAvailable()) {
+    try {
+      const redisPatterns = await findSimilarPatterns(errorType, fileExt, maxMatches);
+
+      if (redisPatterns.length > 0) {
+        return redisPatterns
+          .map(p => convertToHistoricalMatch(p, errorType, fileExt))
+          .sort((a, b) => b.similarity_score - a.similarity_score)
+          .slice(0, maxMatches);
+      }
+    } catch (error) {
+      console.error('Redis pattern lookup failed, using demo patterns:', error);
+    }
+  }
+
+  // Fall back to demo patterns
   const matches = DEMO_HISTORICAL_PATTERNS
     .map((pattern) => {
       let adjustedScore = pattern.similarity_score;
@@ -502,7 +561,7 @@ export async function POST(request: Request): Promise<Response> {
     let recommendedFix: RecommendedFix | null = null;
 
     if (correlate_with_history && limits.historicalCorrelationEnabled) {
-      historicalMatches = findHistoricalMatches(
+      historicalMatches = await findHistoricalMatches(
         errorType,
         file_path || '',
         limits.maxHistoricalMatches

website/app/api/debug-wizard/resolve/route.ts

@@ -0,0 +1,106 @@
+/**
+ * Debug Wizard Resolve API Route
+ *
+ * Stores resolved bug patterns for future reference.
+ * Patterns are stored in Redis for persistence across sessions.
+ */
+
+export const dynamic = 'force-dynamic';
+
+import { NextResponse } from 'next/server';
+import { storeBugPattern, type StoredBugPattern } from '@/lib/redis';
+
+interface ResolveInput {
+  bug_id: string;
+  error_type: string;
+  error_message: string;
+  file_path: string;
+  root_cause: string;
+  fix_applied: string;
+  fix_code?: string;
+  resolution_time_minutes: number;
+  user_id?: string;
+}
+
+/**
+ * Get file extension from path
+ */
+function getFileExtension(filePath: string): string {
+  const parts = filePath.split('.');
+  return parts.length > 1 ? `.${parts[parts.length - 1]}` : 'unknown';
+}
+
+export async function POST(request: Request): Promise<Response> {
+  try {
+    const body: ResolveInput = await request.json();
+    const {
+      bug_id,
+      error_type,
+      error_message,
+      file_path,
+      root_cause,
+      fix_applied,
+      fix_code,
+      resolution_time_minutes,
+      user_id,
+    } = body;
+
+    // Validate required fields
+    if (!bug_id || !error_type || !error_message || !root_cause || !fix_applied) {
+      return NextResponse.json(
+        {
+          success: false,
+          error: 'Missing required fields: bug_id, error_type, error_message, root_cause, fix_applied',
+        },
+        { status: 400 }
+      );
+    }
+
+    // Create pattern to store
+    const pattern: StoredBugPattern = {
+      id: bug_id,
+      date: new Date().toISOString().slice(0, 10),
+      error_type,
+      error_message,
+      file_path: file_path || 'unknown',
+      file_type: file_path ? getFileExtension(file_path) : 'unknown',
+      root_cause,
+      fix_applied,
+      fix_code: fix_code || null,
+      resolution_time_minutes: resolution_time_minutes || 0,
+      user_id,
+    };
+
+    // Store pattern (Redis or in-memory fallback)
+    const stored = await storeBugPattern(pattern);
+
+    if (!stored) {
+      return NextResponse.json(
+        {
+          success: false,
+          error: 'Failed to store pattern',
+        },
+        { status: 500 }
+      );
+    }
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        pattern_id: bug_id,
+        stored: true,
+        message: 'Bug pattern stored successfully. This will help with future debugging!',
+      },
+    });
+  } catch (error) {
+    console.error('Debug wizard resolve error:', error);
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: 'Internal server error',
+      },
+      { status: 500 }
+    );
+  }
+}

website/app/api/debug-wizard/stats/route.ts

@@ -0,0 +1,38 @@
+/**
+ * Debug Wizard Stats API Route
+ *
+ * Returns statistics about stored bug patterns.
+ */
+
+export const dynamic = 'force-dynamic';
+
+import { NextResponse } from 'next/server';
+import { getPatternStats, isRedisAvailable } from '@/lib/redis';
+
+export async function GET(): Promise<Response> {
+  try {
+    const stats = await getPatternStats();
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        total_patterns: stats.total,
+        patterns_by_type: stats.byType,
+        storage_mode: stats.mode,
+        redis_available: isRedisAvailable(),
+        environment: stats.environment,
+        key_prefix: stats.keyPrefix,
+      },
+    });
+  } catch (error) {
+    console.error('Debug wizard stats error:', error);
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: 'Failed to retrieve stats',
+      },
+      { status: 500 }
+    );
+  }
+}

website/app/api/wizards/sbar/start/route.ts

@@ -1,19 +1,26 @@
 import { NextResponse } from 'next/server';
+import { storeWizardSession, type WizardSession } from '@/lib/redis';
 
 export async function POST() {
   try {
     const wizardId = `wizard_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const now = new Date();
+    const expiresAt = new Date(now.getTime() + 60 * 60 * 1000); // 1 hour expiry
 
-    const sessionData = {
+    const sessionData: WizardSession = {
       wizard_id: wizardId,
       wizard_type: 'sbar',
       current_step: 1,
       total_steps: 4,
       collected_data: {},
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      created_at: now.toISOString(),
+      updated_at: now.toISOString(),
+      expires_at: expiresAt.toISOString(),
     };
 
+    // Store session in Redis (falls back to in-memory if unavailable)
+    await storeWizardSession(sessionData);
+
     return NextResponse.json({
       success: true,
       data: {