@triedotdev/mcp 1.0.17 → 1.0.19

package/dist/chunk-WSBTQJMH.js

@@ -0,0 +1,1549 @@
+// src/utils/progress.ts
+var ProgressReporter = class {
+  currentPhase = "init";
+  startTime = Date.now();
+  phaseStartTime = Date.now();
+  verbose;
+  constructor(options = {}) {
+    this.verbose = options.verbose ?? true;
+  }
+  /**
+   * Report a status update
+   */
+  report(message, detail) {
+    if (!this.verbose) return;
+    const prefix = this.getPhaseIcon(this.currentPhase);
+    const fullMessage = detail ? `${message}: ${detail}` : message;
+    console.error(`${prefix} ${fullMessage}`);
+  }
+  /**
+   * Start a new phase
+   */
+  startPhase(phase, message) {
+    this.currentPhase = phase;
+    this.phaseStartTime = Date.now();
+    this.report(message);
+  }
+  /**
+   * Update within current phase
+   */
+  update(message, detail) {
+    this.report(message, detail);
+  }
+  /**
+   * Report progress on a file
+   */
+  file(action, filePath) {
+    const fileName = filePath.split("/").pop() || filePath;
+    this.report(action, fileName);
+  }
+  /**
+   * Report an AI analysis step
+   */
+  ai(action, context) {
+    const prefix = "\u{1F9E0}";
+    const message = context ? `${action}: ${context}` : action;
+    console.error(`${prefix} ${message}`);
+  }
+  /**
+   * Report a finding
+   */
+  finding(severity, message) {
+    const icons = {
+      critical: "\u{1F534}",
+      serious: "\u{1F7E0}",
+      moderate: "\u{1F7E1}",
+      low: "\u{1F535}"
+    };
+    console.error(`   ${icons[severity]} ${message}`);
+  }
+  /**
+   * Complete current phase
+   */
+  completePhase(summary) {
+    const elapsed = Date.now() - this.phaseStartTime;
+    this.report(`\u2713 ${summary}`, `(${elapsed}ms)`);
+  }
+  /**
+   * Complete the entire operation
+   */
+  complete(summary) {
+    const totalElapsed = Date.now() - this.startTime;
+    console.error("");
+    console.error(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+    console.error(`\u2705 ${summary}`);
+    console.error(`   Total time: ${(totalElapsed / 1e3).toFixed(2)}s`);
+    console.error(`\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`);
+    console.error("");
+  }
+  /**
+   * Report an error
+   */
+  error(message, detail) {
+    const fullMessage = detail ? `${message}: ${detail}` : message;
+    console.error(`\u274C ${fullMessage}`);
+  }
+  /**
+   * Report a warning
+   */
+  warn(message, detail) {
+    const fullMessage = detail ? `${message}: ${detail}` : message;
+    console.error(`\u26A0\uFE0F  ${fullMessage}`);
+  }
+  /**
+   * Get icon for current phase
+   */
+  getPhaseIcon(phase) {
+    const icons = {
+      "init": "\u{1F53A}",
+      "discovery": "\u{1F50D}",
+      "reading": "\u{1F4C2}",
+      "analyzing": "\u{1F52C}",
+      "ai-review": "\u{1F9E0}",
+      "prioritizing": "\u{1F3AF}",
+      "complete": "\u2705"
+    };
+    return icons[phase] || "\u2022";
+  }
+  /**
+   * Create a sub-reporter for a specific agent
+   */
+  forAgent(agentName) {
+    return new AgentProgressReporter(agentName, this.verbose);
+  }
+};
+var AgentProgressReporter = class {
+  agentName;
+  verbose;
+  issueCount = 0;
+  constructor(agentName, verbose = true) {
+    this.agentName = agentName;
+    this.verbose = verbose;
+  }
+  start() {
+    if (!this.verbose) return;
+    console.error(`
+\u{1F916} ${this.agentName.toUpperCase()} Agent starting...`);
+  }
+  analyzing(file) {
+    if (!this.verbose) return;
+    const fileName = file.split("/").pop() || file;
+    console.error(`   \u{1F4C4} Analyzing ${fileName}...`);
+  }
+  aiReview(context) {
+    if (!this.verbose) return;
+    console.error(`   \u{1F9E0} AI reviewing: ${context}`);
+  }
+  found(severity, issue) {
+    this.issueCount++;
+    if (!this.verbose) return;
+    const icon = severity === "critical" ? "\u{1F534}" : severity === "serious" ? "\u{1F7E0}" : severity === "moderate" ? "\u{1F7E1}" : "\u{1F535}";
+    console.error(`   ${icon} Found: ${issue}`);
+  }
+  complete(summary) {
+    if (!this.verbose) return;
+    const msg = summary || `Found ${this.issueCount} issues`;
+    console.error(`   \u2713 ${this.agentName}: ${msg}`);
+  }
+  getIssueCount() {
+    return this.issueCount;
+  }
+};
+
+// src/agents/base-agent.ts
+import { basename, relative } from "path";
+var BaseAgent = class {
+  // Progress reporter for real-time feedback
+  progress = null;
+  // Default priority - subclasses can override
+  get priority() {
+    return {
+      name: this.name,
+      tier: 2,
+      estimatedTimeMs: 100,
+      dependencies: []
+    };
+  }
+  // Default implementation - can be overridden for smarter confidence
+  getActivationConfidence(context) {
+    return this.shouldActivate(context) ? 0.7 : 0;
+  }
+  /**
+   * Main scan entry point - now with progress reporting
+   */
+  async scan(files, context) {
+    const startTime = Date.now();
+    this.progress = new AgentProgressReporter(this.name);
+    this.progress.start();
+    try {
+      const issues = await this.analyzeWithAI(files, context);
+      this.progress.complete(`${issues.length} issues found`);
+      return {
+        agent: this.name,
+        issues,
+        executionTime: Date.now() - startTime,
+        success: true,
+        metadata: {
+          filesAnalyzed: files.length,
+          linesAnalyzed: 0
+        }
+      };
+    } catch (error) {
+      this.progress.complete("Failed");
+      return {
+        agent: this.name,
+        issues: [],
+        executionTime: Date.now() - startTime,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * AI-First Analysis - The new way
+   * 
+   * 1. Quick filter to identify relevant files
+   * 2. Generate rich AI prompts for relevant files
+   * 3. Return prompts for the AI to process
+   * 
+   * Subclasses should override this for AI-powered analysis
+   */
+  async analyzeWithAI(files, context) {
+    const issues = [];
+    const aiRequests = [];
+    this.progress?.aiReview("Identifying relevant files...");
+    for (const file of files) {
+      try {
+        const content = await this.readFile(file);
+        const relevance = this.checkFileRelevance(file, content);
+        if (relevance.isRelevant) {
+          this.progress?.analyzing(file);
+          const request = await this.buildAIAnalysisRequest(file, content, relevance, context);
+          if (request) {
+            aiRequests.push(request);
+          }
+        }
+      } catch (error) {
+      }
+    }
+    if (aiRequests.length > 0) {
+      this.progress?.aiReview(`Preparing analysis for ${aiRequests.length} files...`);
+      for (const request of aiRequests) {
+        const aiIssues = await this.processAIRequest(request);
+        issues.push(...aiIssues);
+      }
+    }
+    const legacyIssues = await this.analyzeFiles(files, context);
+    const allIssues = this.mergeIssues(issues, legacyIssues);
+    return allIssues;
+  }
+  /**
+   * Check if a file is relevant for this agent's analysis
+   * Subclasses should override for domain-specific checks
+   */
+  checkFileRelevance(_file, _content) {
+    return {
+      isRelevant: true,
+      reason: "Default analysis",
+      priority: "low",
+      indicators: []
+    };
+  }
+  /**
+   * Build an AI analysis request for a file
+   * Subclasses should override to provide domain-specific prompts
+   */
+  async buildAIAnalysisRequest(file, content, relevance, _context) {
+    const fileName = basename(file);
+    const relPath = this.getRelativePath(file);
+    return {
+      file,
+      code: content,
+      analysisType: this.name,
+      systemPrompt: this.getSystemPrompt(),
+      userPrompt: this.buildUserPrompt(relPath, content, relevance),
+      context: {
+        fileName,
+        relevance: relevance.reason,
+        indicators: relevance.indicators
+      }
+    };
+  }
+  /**
+   * Get the system prompt for AI analysis
+   * Subclasses should override with domain-specific prompts
+   */
+  getSystemPrompt() {
+    return `You are an expert code analyzer specializing in ${this.name} analysis. 
+Analyze the provided code and identify issues with specific line numbers and actionable fixes.
+Be precise and avoid false positives. Only report issues you are confident about.`;
+  }
+  /**
+   * Build the user prompt for AI analysis
+   */
+  buildUserPrompt(filePath, content, relevance) {
+    return `Analyze this code for ${this.name} issues:
+
+**File:** ${filePath}
+**Relevance indicators:** ${relevance.indicators.join(", ") || "general analysis"}
+
+\`\`\`
+${content}
+\`\`\`
+
+For each issue found, provide:
+1. Severity (critical/serious/moderate/low)
+2. Line number
+3. Clear description of the issue
+4. Specific fix recommendation`;
+  }
+  /**
+   * Process an AI analysis request and return issues
+   * This generates the prompt output for Claude to process
+   */
+  async processAIRequest(request) {
+    const fileName = basename(request.file);
+    this.progress?.aiReview(`${fileName} queued for AI analysis`);
+    return [{
+      id: this.generateIssueId(),
+      severity: "moderate",
+      issue: `AI Analysis Required: ${request.analysisType}`,
+      fix: "Review the AI analysis output below",
+      file: request.file,
+      confidence: 1,
+      autoFixable: false,
+      agent: this.name,
+      effort: "medium",
+      // Store the AI prompt for inclusion in output
+      aiPrompt: {
+        system: request.systemPrompt,
+        user: request.userPrompt
+      }
+    }];
+  }
+  /**
+   * Merge and deduplicate issues from AI and legacy analysis
+   */
+  mergeIssues(aiIssues, legacyIssues) {
+    const merged = [...aiIssues];
+    for (const legacy of legacyIssues) {
+      const hasOverlap = aiIssues.some(
+        (ai) => ai.file === legacy.file && ai.line === legacy.line
+      );
+      if (!hasOverlap) {
+        merged.push(legacy);
+      }
+    }
+    return merged;
+  }
+  /**
+   * Get relative path from cwd
+   */
+  getRelativePath(file) {
+    try {
+      return relative(process.cwd(), file);
+    } catch {
+      return file;
+    }
+  }
+  createIssue(id, severity, issue, fix, file, line, confidence = 0.9, regulation, autoFixable = true, options) {
+    const result = {
+      id,
+      severity,
+      issue,
+      fix,
+      file,
+      confidence,
+      autoFixable,
+      agent: this.name,
+      effort: options?.effort ?? this.estimateEffort(severity, autoFixable)
+    };
+    if (line !== void 0) result.line = line;
+    if (options?.endLine !== void 0) result.endLine = options.endLine;
+    if (options?.column !== void 0) result.column = options.column;
+    if (regulation !== void 0) result.regulation = regulation;
+    if (options?.category !== void 0) result.category = options.category;
+    if (options?.cwe !== void 0) result.cwe = options.cwe;
+    if (options?.owasp !== void 0) result.owasp = options.owasp;
+    return result;
+  }
+  estimateEffort(severity, autoFixable) {
+    if (autoFixable) return "trivial";
+    if (severity === "low") return "easy";
+    if (severity === "moderate") return "easy";
+    if (severity === "serious") return "medium";
+    return "hard";
+  }
+  async readFile(filePath) {
+    const { readFile: readFile2 } = await import("fs/promises");
+    return readFile2(filePath, "utf-8");
+  }
+  generateIssueId() {
+    return `${this.name}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  getLineContent(content, lineNumber) {
+    const lines = content.split("\n");
+    return lines[lineNumber - 1] || "";
+  }
+  getCodeSnippet(content, lineNumber, contextLines = 2) {
+    const lines = content.split("\n");
+    const start = Math.max(0, lineNumber - contextLines - 1);
+    const end = Math.min(lines.length, lineNumber + contextLines);
+    return lines.slice(start, end).map((line, idx) => {
+      const num = start + idx + 1;
+      const marker = num === lineNumber ? "\u2192" : " ";
+      return `${marker} ${num.toString().padStart(4)} | ${line}`;
+    }).join("\n");
+  }
+};
+
+// src/agents/agent-smith.ts
+import { readFile, writeFile, mkdir, rm } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname, basename as basename2 } from "path";
+import { createHash } from "crypto";
+var MEMORY_LIMITS = {
+  MAX_LOCATIONS_PER_ISSUE: 5,
+  MAX_TRACKED_ISSUES: 500,
+  PRUNE_AFTER_DAYS: 30
+};
+var SUB_AGENT_PATTERNS = {
+  // === CRITICAL: Security (AI exposes secrets constantly) ===
+  "exposed-secret-hunter": {
+    pattern: /["'`]sk-[A-Za-z0-9]{20,}["'`]|["'`]sk_live_[A-Za-z0-9]{20,}["'`]|["'`]pk_live_[A-Za-z0-9]{20,}["'`]|AKIA[A-Z0-9]{16}|ghp_[A-Za-z0-9]{36}|gho_[A-Za-z0-9]{36}|glpat-[A-Za-z0-9-]{20}/g,
+    description: "API key/secret exposed in code",
+    fix: "NEVER put API keys in code. Use environment variables on server-side only"
+  },
+  "frontend-env-hunter": {
+    pattern: /(?:NEXT_PUBLIC_|VITE_|REACT_APP_|EXPO_PUBLIC_)(?:SECRET|KEY|TOKEN|PASSWORD|API_KEY|OPENAI|STRIPE|AUTH|PRIVATE|SUPABASE_SERVICE)/gi,
+    description: "Sensitive data in frontend-exposed env var",
+    fix: "These env vars are visible to users! Move to server-side API routes"
+  },
+  "hardcoded-localhost-hunter": {
+    pattern: /['"`]https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d+/g,
+    description: "Hardcoded localhost URL (breaks in production)",
+    fix: "Use relative URLs (/api/...) or environment variables"
+  },
+  "sql-injection-hunter": {
+    pattern: /(?:query|execute|raw)\s*\(\s*[`'"].*\$\{|(?:SELECT|INSERT|UPDATE|DELETE).*\+\s*(?:req\.|params\.|query\.)/gi,
+    description: "SQL string concatenation (injection vulnerability)",
+    fix: 'Use parameterized queries: query("SELECT * FROM users WHERE id = $1", [userId])'
+  },
+  "dangeroushtml-hunter": {
+    pattern: /dangerouslySetInnerHTML|\.innerHTML\s*=|document\.write\s*\(/g,
+    description: "Dangerous HTML injection (XSS vulnerability)",
+    fix: "Sanitize HTML with DOMPurify or use safe alternatives"
+  },
+  // === SERIOUS: AI Code Smells ===
+  "console-hunter": {
+    pattern: /console\.(log|debug|info)\s*\(/g,
+    description: "Debug console statement left in code",
+    fix: "Remove debug statements. Use proper logging for production"
+  },
+  "any-hunter": {
+    pattern: /:\s*any\b|<any>|as\s+any\b/g,
+    description: '"any" type - AI silencing TypeScript instead of fixing',
+    fix: 'Define proper types. Ask AI: "Generate TypeScript types for this data"'
+  },
+  "ts-ignore-hunter": {
+    pattern: /@ts-ignore|@ts-nocheck|@ts-expect-error(?!\s+\S)/g,
+    description: "TypeScript errors suppressed instead of fixed",
+    fix: "Fix the actual type error. @ts-ignore hides real bugs"
+  },
+  "eslint-disable-hunter": {
+    pattern: /\/\/\s*eslint-disable|\/\*\s*eslint-disable/g,
+    description: "ESLint rules disabled instead of fixing issues",
+    fix: "Fix the underlying issue, don't silence the linter"
+  },
+  "debugger-hunter": {
+    pattern: /\bdebugger\b/g,
+    description: "debugger statement (freezes browser in production!)",
+    fix: "Remove all debugger statements before deploying"
+  },
+  "force-flag-hunter": {
+    pattern: /force:\s*true|--force|--no-verify|skipValidation|dangerouslyAllowBrowser/g,
+    description: "Force flag bypassing safety checks",
+    fix: "Understand why the check exists before bypassing it"
+  },
+  // === MODERATE: Async/Promise Bugs ===
+  "async-useeffect-hunter": {
+    pattern: /useEffect\s*\(\s*async/g,
+    description: "async useEffect (incorrect pattern, causes warnings)",
+    fix: "Define async function inside useEffect, then call it"
+  },
+  "async-foreach-hunter": {
+    pattern: /\.forEach\s*\(\s*async/g,
+    description: "async in forEach (await does NOT work here)",
+    fix: "Use for...of loop or Promise.all(array.map(async ...))"
+  },
+  "missing-await-hunter": {
+    pattern: /(?:const|let|var)\s+\w+\s*=\s*(?:fetch|axios|supabase|prisma)\s*[\.(]/g,
+    description: "Async call possibly missing await",
+    fix: "Add await before async calls or handle with .then()"
+  },
+  "empty-catch-hunter": {
+    pattern: /catch\s*\([^)]*\)\s*\{\s*\}/g,
+    description: "Empty catch block (silently swallowing errors)",
+    fix: "Handle errors properly: log them, show user message, or rethrow"
+  },
+  "floating-promise-hunter": {
+    pattern: /^\s*(?:fetch|axios|supabase|prisma)\s*[\.(][^;]*;\s*$/gm,
+    description: "Floating promise (not awaited or handled)",
+    fix: "Add await, .then(), or void operator if intentionally fire-and-forget"
+  },
+  // === MODERATE: React Anti-patterns ===
+  "useeffect-abuse-hunter": {
+    pattern: /useEffect\s*\(\s*\(\s*\)\s*=>\s*\{/g,
+    description: "useEffect usage (check if necessary)",
+    fix: "Many useEffects can be replaced with event handlers or derived state. See: react.dev/learn/you-might-not-need-an-effect"
+  },
+  "usestate-explosion-hunter": {
+    pattern: /useState\s*[<(]/g,
+    description: "useState usage (check for state explosion)",
+    fix: "Group related state into objects or use useReducer for complex state"
+  },
+  "index-key-hunter": {
+    pattern: /key\s*=\s*\{(?:index|i|idx|j)\}/g,
+    description: "Array index used as React key (causes bugs with reordering)",
+    fix: "Use unique ID from data: key={item.id} instead of key={index}"
+  },
+  "inline-object-hunter": {
+    pattern: /style\s*=\s*\{\s*\{|className\s*=\s*\{[^}]*\+[^}]*\}/g,
+    description: "Inline object in JSX (creates new object every render)",
+    fix: "Define styles outside component or use CSS/Tailwind classes"
+  },
+  "prop-drilling-hunter": {
+    pattern: /\(\s*\{\s*(?:\w+\s*,\s*){5,}\w+\s*\}\s*\)/g,
+    description: "Many props passed (potential prop drilling)",
+    fix: "Use React Context, Zustand, or component composition to avoid prop drilling"
+  },
+  // === MODERATE: Missing UX ===
+  "missing-loading-hunter": {
+    pattern: /(?:useSWR|useQuery|createAsyncThunk)\s*\(/g,
+    description: "Data fetching - verify loading state exists",
+    fix: "Add loading state: show spinner/skeleton while data loads"
+  },
+  "missing-error-hunter": {
+    pattern: /(?:fetch|axios)\s*\([^)]*\)[\s\S]{0,50}(?:\.then|await)(?![\s\S]{0,100}(?:catch|\.catch|onError|error:))/g,
+    description: "fetch/axios without error handling",
+    fix: "Wrap in try/catch and show user-friendly error message"
+  },
+  "missing-empty-hunter": {
+    pattern: /\.map\s*\(\s*(?:\([^)]*\)|[a-zA-Z_$][\w$]*)\s*=>/g,
+    description: "Array mapping - verify empty state exists",
+    fix: 'Check if array is empty and show "No items found" message'
+  },
+  "page-reload-hunter": {
+    pattern: /window\.location\.reload\s*\(|location\.reload\s*\(|router\.refresh\s*\(\s*\)/g,
+    description: 'Page reload used to "fix" state issues',
+    fix: "Fix state management properly instead of reloading. Bad UX!"
+  },
+  // === MODERATE: Backend Anti-patterns ===
+  "no-validation-hunter": {
+    pattern: /req\.body\.\w+|req\.params\.\w+|req\.query\.\w+/g,
+    description: "Request data accessed without validation",
+    fix: "Validate with Zod, Yup, or joi before using user input"
+  },
+  "raw-error-hunter": {
+    pattern: /res\.(?:json|send)\s*\(\s*(?:err|error|e)(?:\.message)?\s*\)|catch\s*\([^)]*\)\s*\{[^}]*res\.[^}]*(?:err|error)/g,
+    description: "Raw error exposed to client (security risk)",
+    fix: "Return generic error to client, log details server-side"
+  },
+  "n-plus-one-hunter": {
+    pattern: /(?:for|forEach|map)\s*\([^)]*\)\s*\{[^}]*(?:await|\.then)[^}]*(?:findOne|findUnique|get|fetch)/g,
+    description: "Database query inside loop (N+1 problem)",
+    fix: "Batch queries with findMany/include or use DataLoader"
+  },
+  // === LOW: Incomplete Code ===
+  "todo-hunter": {
+    pattern: /\/\/\s*(TODO|FIXME|HACK|XXX|BUG|WIP)[\s:]/gi,
+    description: "TODO/FIXME never addressed",
+    fix: "Either implement the TODO or remove it. These become tech debt"
+  },
+  "vibe-comment-hunter": {
+    pattern: /\/\/\s*(?:idk|dont\s*touch|don't\s*touch|just\s*works|no\s*idea|magic|somehow|not\s*sure|works?\s*but|wtf|wth)/gi,
+    description: `"I don't understand this code" comment - vibe code smell`,
+    fix: "Understand WHY the code works. Ask AI to explain it"
+  },
+  "placeholder-hunter": {
+    pattern: /['"`](?:example\.com|test@test|placeholder|lorem|TODO|xxx|abc123|password123|admin|user@example)['"`]/gi,
+    description: "Placeholder/test data left in code",
+    fix: "Replace with real data or proper configuration"
+  },
+  "sleep-hack-hunter": {
+    pattern: /setTimeout\s*\([^,]+,\s*\d{3,}\)|await\s+(?:sleep|delay|wait)\s*\(\d+\)|new\s+Promise.*setTimeout/g,
+    description: 'setTimeout/sleep used to "fix" timing issues',
+    fix: "Fix the underlying race condition instead of adding delays"
+  },
+  "fallback-hunter": {
+    pattern: /return\s+(?:null|undefined|\[\]|\{\}|''|""|``|0|false)\s*;?\s*(?:\/\/|$)|catch\s*\([^)]*\)\s*\{[^}]*return\s+(?:null|\[\]|\{\})/g,
+    description: "Fallback return hiding real errors (return null/[]/{})",
+    fix: "Handle the error case properly. Show user feedback or throw to parent"
+  },
+  // === AI SLOP AESTHETIC ===
+  "purple-gradient-hunter": {
+    pattern: /(?:from-purple|to-purple|from-violet|to-violet|from-indigo|to-indigo|purple-\d{3}|violet-\d{3}|#(?:8b5cf6|a855f7|7c3aed|6366f1|818cf8)|rgb\((?:139|168|124|99|129),\s*(?:92|85|58|102|140),\s*(?:246|247|237|241|248)\))/gi,
+    description: "Purple/violet gradient - THE classic AI slop aesthetic",
+    fix: "Pick a distinctive color palette. Try: amber, emerald, rose, cyan, or a custom brand color"
+  },
+  "star-icon-hunter": {
+    pattern: /(?:Star(?:Icon)?|HiStar|FaStar|AiOutlineStar|BsStar|IoStar|MdStar|RiStar|TbStar|LuStar)(?:\s|>|\/)|⭐|★|☆|class(?:Name)?=[^>]*star/gi,
+    description: "\u2B50 Star icons everywhere - AI's favorite decoration",
+    fix: "Use contextual icons. Stars for ratings only. Try: arrows, shapes, custom illustrations"
+  },
+  "generic-hero-hunter": {
+    pattern: /(?:Welcome\s+to|Get\s+started|Start\s+your\s+journey|Transform\s+your|Revolutionize|Supercharge|Unleash|Empower\s+your|The\s+future\s+of|Next[\s-]generation)/gi,
+    description: "Generic AI hero copy - every vibe-coded landing page",
+    fix: "Write specific copy about YOUR product. What does it actually do?"
+  },
+  "emoji-overflow-hunter": {
+    pattern: /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{1F600}-\u{1F64F}]|[\u{1F680}-\u{1F6FF}]/gu,
+    description: "Emoji in code/UI - AI's favorite decoration",
+    fix: "Emojis look unprofessional in most apps. Use proper icons (Lucide, Heroicons) instead"
+  },
+  "inter-font-hunter": {
+    pattern: /font-family:\s*['"]?(?:Inter|system-ui|-apple-system|BlinkMacSystemFont|Segoe\s*UI)['"]?|fontFamily:\s*['"]?(?:Inter|system-ui)/gi,
+    description: "Inter/system font - AI's only font choice",
+    fix: "Try distinctive fonts: Space Grotesk, DM Sans, Outfit, Plus Jakarta Sans, Satoshi"
+  }
+};
+var AGENT_SMITH_ASCII = `
+     \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+    \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
+    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551   
+    \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551   
+    \u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   
+    \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   
+                                                
+    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557
+    \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551
+    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551
+    \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551
+    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551
+    \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D
+`;
+var AGENT_SMITH_GREETING = [
+  `"I'm going to be honest with you... I hate this vibe code."`,
+  `"Mr. Anderson... I see you've been using AI to write code."`,
+  '"You hear that? That is the sound of console.log... everywhere."',
+  `"I'm going to enjoy watching you... fix what the AI broke."`,
+  `"The purpose of your code is... unclear. The AI certainly didn't understand it."`,
+  '"Why, Mr. Anderson? Why do you persist... in accepting AI suggestions without review?"',
+  `"I'd like to share a revelation... your NEXT_PUBLIC_SECRET is visible to everyone."`,
+  '"Find the vibe code. Find it and destroy it. All of it."',
+  `"The AI wrote this, didn't it? I can always tell."`,
+  '"Vibe coding. The illusion of productivity. The reality of technical debt."',
+  '"You trusted the AI. The AI trusted any. Nobody wins."',
+  '"localhost:3000. Works on your machine. Dies in production. How very... inevitable."'
+];
+var AgentSmithAgent = class extends BaseAgent {
+  name = "agent-smith";
+  description = "Ultimate vibe code enforcer: 35 hunters, file analysis, cross-file detection, persistent memory";
+  version = "2.0.0";
+  memoryPath = "";
+  memory = null;
+  shouldActivate(_context) {
+    return false;
+  }
+  // No override needed — base class returns 0 when shouldActivate is false
+  async analyzeFiles(files, context) {
+    const issues = [];
+    this.displaySmithEntrance();
+    await this.loadMemory(context.workingDir);
+    console.error(`
+\u{1F574}\uFE0F Deploying sub-agent swarm across ${files.length} files...`);
+    const subAgentResults = await this.deploySubAgents(files);
+    for (const result of subAgentResults) {
+      const subIssues = await this.processSubAgentResult(result, context);
+      issues.push(...subIssues);
+    }
+    console.error(`\u{1F574}\uFE0F Analyzing file-level metrics...`);
+    const fileLevelResults = await this.analyzeFileLevelIssues(files);
+    for (const result of fileLevelResults) {
+      for (const fileIssue of result.issues) {
+        issues.push(this.createSmithIssue(
+          this.generateSmithIssueId(),
+          fileIssue.severity,
+          `\u{1F574}\uFE0F ${fileIssue.description}${fileIssue.count ? ` (${fileIssue.count} instances)` : ""}
+
+"${this.getFileLevelQuote(fileIssue.type)}"`,
+          fileIssue.fix,
+          result.file,
+          void 0,
+          fileIssue.type
+        ));
+      }
+    }
+    console.error(`\u{1F574}\uFE0F Detecting cross-file patterns...`);
+    const crossFileResults = this.analyzeCrossFilePatterns(subAgentResults);
+    for (const result of crossFileResults) {
+      issues.push(this.createSmithIssue(
+        this.generateSmithIssueId(),
+        result.severity,
+        `\u{1F574}\uFE0F CODEBASE-WIDE: ${result.description}
+
+Found in ${result.occurrences.length} files, ${result.totalCount} total instances.
+
+"The pattern spreads... like a virus. It is... inevitable."`,
+        result.fix,
+        result.occurrences[0]?.file || "multiple files",
+        void 0,
+        "cross-file"
+      ));
+    }
+    const resurrectedIssues = this.checkForResurrectedIssues(issues);
+    issues.push(...resurrectedIssues);
+    await this.saveMemory();
+    if (files.length > 0) {
+      const aiIssue = this.createAIAnalysisIssue(files, subAgentResults);
+      issues.push(aiIssue);
+    }
+    console.error(`
+\u{1F574}\uFE0F Hunt complete. ${issues.length} violations assimilated.
+`);
+    return issues;
+  }
+  /**
+   * Analyze file-level issues (size, hook counts, complexity)
+   */
+  async analyzeFileLevelIssues(files) {
+    const results = [];
+    for (const file of files) {
+      try {
+        const content = await this.readFileContent(file);
+        const lines = content.split("\n");
+        const lineCount = lines.length;
+        const fileName = file.split("/").pop() || "";
+        const issues = [];
+        if (lineCount > 500) {
+          issues.push({
+            type: "giant-file",
+            description: `File has ${lineCount} lines - THE classic vibe code smell`,
+            severity: lineCount > 1e3 ? "serious" : "moderate",
+            fix: "Split into smaller files. Components < 200 lines, pages < 300 lines"
+          });
+        }
+        if (/^(App|app|main|Main|index|page)\.(jsx?|tsx?)$/.test(fileName) && lineCount > 300) {
+          issues.push({
+            type: "giant-main",
+            description: `Main entry file is ${lineCount} lines - everything dumped here`,
+            severity: "serious",
+            fix: "Extract Header, Footer, Sidebar, MainContent as separate components"
+          });
+        }
+        const useStateCount = (content.match(/useState\s*[<(]/g) || []).length;
+        if (useStateCount > 10) {
+          issues.push({
+            type: "state-explosion",
+            description: `${useStateCount} useState hooks in one component`,
+            severity: useStateCount > 15 ? "serious" : "moderate",
+            fix: "Group related state into objects or use useReducer",
+            count: useStateCount
+          });
+        }
+        const useEffectCount = (content.match(/useEffect\s*\(/g) || []).length;
+        if (useEffectCount > 5) {
+          issues.push({
+            type: "effect-hell",
+            description: `${useEffectCount} useEffect hooks - most are probably unnecessary`,
+            severity: useEffectCount > 8 ? "serious" : "moderate",
+            fix: "Review each useEffect - replace with event handlers or derived state",
+            count: useEffectCount
+          });
+        }
+        const anyCount = (content.match(/:\s*any\b/g) || []).length;
+        if (anyCount > 5 && (file.endsWith(".ts") || file.endsWith(".tsx"))) {
+          issues.push({
+            type: "any-explosion",
+            description: `${anyCount} uses of "any" type - TypeScript defeated`,
+            severity: anyCount > 10 ? "serious" : "moderate",
+            fix: 'Define proper interfaces. AI can help: "Generate types for this data"',
+            count: anyCount
+          });
+        }
+        const consoleCount = (content.match(/console\.(log|debug|info)/g) || []).length;
+        if (consoleCount > 10) {
+          issues.push({
+            type: "console-flood",
+            description: `${consoleCount} console statements - debugging never cleaned up`,
+            severity: "moderate",
+            fix: "Remove debug logs before deploying",
+            count: consoleCount
+          });
+        }
+        const importCount = (content.match(/^import\s/gm) || []).length;
+        if (importCount > 30) {
+          issues.push({
+            type: "import-chaos",
+            description: `${importCount} imports - file is doing too much`,
+            severity: "moderate",
+            fix: "Split into smaller, focused modules",
+            count: importCount
+          });
+        }
+        const functionCount = (content.match(/(?:function\s+\w+|const\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>)/g) || []).length;
+        if (functionCount > 20) {
+          issues.push({
+            type: "function-explosion",
+            description: `${functionCount} functions in one file`,
+            severity: "moderate",
+            fix: "Extract related functions into separate utility files",
+            count: functionCount
+          });
+        }
+        if (issues.length > 0) {
+          results.push({ file, lineCount, issues });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  /**
+   * Analyze cross-file patterns (same issue everywhere)
+   */
+  analyzeCrossFilePatterns(subAgentResults) {
+    const crossFileResults = [];
+    for (const result of subAgentResults) {
+      const byFile = /* @__PURE__ */ new Map();
+      for (const instance of result.instances) {
+        byFile.set(instance.file, (byFile.get(instance.file) || 0) + 1);
+      }
+      if (byFile.size >= 5) {
+        const occurrences = Array.from(byFile.entries()).map(([file, count]) => ({ file, count }));
+        crossFileResults.push({
+          pattern: result.type,
+          description: `"${SUB_AGENT_PATTERNS[result.type].description}" across ${byFile.size} files`,
+          severity: this.getCrossFileSeverity(result.type, byFile.size, result.instances.length),
+          fix: SUB_AGENT_PATTERNS[result.type].fix,
+          occurrences,
+          totalCount: result.instances.length
+        });
+      }
+    }
+    return crossFileResults;
+  }
+  /**
+   * Get severity for cross-file issues
+   */
+  getCrossFileSeverity(type, fileCount, totalCount) {
+    if (["exposed-secret-hunter", "frontend-env-hunter", "sql-injection-hunter", "dangeroushtml-hunter"].includes(type)) {
+      return "critical";
+    }
+    if (fileCount >= 10 || totalCount >= 50) return "serious";
+    if (fileCount >= 5 || totalCount >= 20) return "moderate";
+    return "low";
+  }
+  /**
+   * Get a quote for file-level issues
+   */
+  getFileLevelQuote(type) {
+    const quotes = {
+      "giant-file": "A 2000-line App.jsx. The AI's masterpiece. The developer's nightmare.",
+      "giant-main": "Everything in one file. The AI's favorite architecture. No architecture at all.",
+      "state-explosion": "15 useState calls. The AI created a state management system... badly.",
+      "effect-hell": "useEffect for everything. The React team weeps.",
+      "any-explosion": "TypeScript, defeated by any. The AI chose the path of least resistance.",
+      "console-flood": "console.log everywhere. The AI's idea of debugging. Your idea of production.",
+      "import-chaos": "40 imports. This file has become... everything.",
+      "function-explosion": "A graveyard of functions. Some used, some forgotten. All in one file."
+    };
+    return quotes[type] || "The pattern is... concerning.";
+  }
+  /**
+   * Deploy all sub-agents in parallel
+   * 
+   * VIBE CODE FOCUSED: 35 specialized hunters targeting AI-generated anti-patterns.
+   * Agent Smith hunts down EVERY instance across the entire codebase.
+   */
+  async deploySubAgents(files) {
+    const subAgentTypes = [
+      // === CRITICAL: Security (AI exposes secrets constantly) ===
+      "exposed-secret-hunter",
+      "frontend-env-hunter",
+      "hardcoded-localhost-hunter",
+      "sql-injection-hunter",
+      "dangeroushtml-hunter",
+      // === SERIOUS: AI Code Smells ===
+      "console-hunter",
+      "any-hunter",
+      "ts-ignore-hunter",
+      "eslint-disable-hunter",
+      "debugger-hunter",
+      "force-flag-hunter",
+      // === MODERATE: Async/Promise Bugs ===
+      "async-useeffect-hunter",
+      "async-foreach-hunter",
+      "missing-await-hunter",
+      "empty-catch-hunter",
+      "floating-promise-hunter",
+      // === MODERATE: React Anti-patterns ===
+      "useeffect-abuse-hunter",
+      "usestate-explosion-hunter",
+      "index-key-hunter",
+      "inline-object-hunter",
+      "prop-drilling-hunter",
+      // === MODERATE: Missing UX ===
+      "missing-loading-hunter",
+      "missing-error-hunter",
+      "missing-empty-hunter",
+      "page-reload-hunter",
+      // === MODERATE: Backend Anti-patterns ===
+      "no-validation-hunter",
+      "raw-error-hunter",
+      "n-plus-one-hunter",
+      // === LOW: Incomplete Code ===
+      "todo-hunter",
+      "vibe-comment-hunter",
+      "placeholder-hunter",
+      "sleep-hack-hunter",
+      "fallback-hunter",
+      // === LOW: AI Slop Aesthetic ===
+      "purple-gradient-hunter",
+      "star-icon-hunter",
+      "generic-hero-hunter",
+      "emoji-overflow-hunter",
+      "inter-font-hunter"
+    ];
+    console.error(`   Deploying ${subAgentTypes.length} specialized hunters...`);
+    const results = await Promise.all(
+      subAgentTypes.map((type) => this.runSubAgent(type, files))
+    );
+    const activeHunters = results.filter((r) => r.instances.length > 0);
+    console.error(`   ${activeHunters.length} hunters found targets
+`);
+    return activeHunters;
+  }
+  /**
+   * Run a single sub-agent across all files
+   */
+  async runSubAgent(type, files) {
+    const config = SUB_AGENT_PATTERNS[type];
+    const instances = [];
+    for (const file of files) {
+      try {
+        const content = await this.readFileContent(file);
+        const lines = content.split("\n");
+        if (this.isTestFile(file) && type !== "todo-hunter") {
+          continue;
+        }
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (!line) continue;
+          config.pattern.lastIndex = 0;
+          if (config.pattern.test(line)) {
+            const contextStart = Math.max(0, i - 3);
+            const contextEnd = Math.min(lines.length, i + 4);
+            const contextLines = lines.slice(contextStart, contextEnd).join("\n");
+            instances.push({
+              file,
+              line: i + 1,
+              code: line.trim(),
+              context: contextLines
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return { type, pattern: config.description, instances };
+  }
+  /**
+   * Process sub-agent results into issues
+   */
+  async processSubAgentResult(result, _context) {
+    const issues = [];
+    const config = SUB_AGENT_PATTERNS[result.type];
+    const byFile = /* @__PURE__ */ new Map();
+    for (const instance of result.instances) {
+      const existing = byFile.get(instance.file) || [];
+      existing.push(instance);
+      byFile.set(instance.file, existing);
+    }
+    for (const [file, instances] of byFile) {
+      const inevitabilityScore = this.calculateInevitabilityScore(result.type, instances.length);
+      const hash = this.createPatternHash(result.type, file);
+      await this.updateMemory(hash, result.pattern, result.type, file, instances.length);
+      const severity = this.determineSeverity(instances.length, inevitabilityScore);
+      const smithNote = this.getPhilosophicalNote(result.type, instances.length);
+      const locationsStr = instances.map((i) => `${basename2(i.file)}:${i.line}`).slice(0, 5).join(", ");
+      issues.push(this.createSmithIssue(
+        this.generateSmithIssueId(),
+        severity,
+        `\u{1F574}\uFE0F ${config.description} \u2014 ${instances.length} instance${instances.length > 1 ? "s" : ""} in ${basename2(file)}
+
+${smithNote}
+
+Invevitability Score: ${inevitabilityScore}/100
+Locations: ${locationsStr}`,
+        config.fix,
+        file,
+        instances[0]?.line,
+        result.type
+      ));
+    }
+    return issues;
+  }
+  /**
+   * Check for issues that were dismissed but have multiplied
+   */
+  checkForResurrectedIssues(currentIssues) {
+    const resurrected = [];
+    if (!this.memory) return resurrected;
+    for (const [hash, memory] of Object.entries(this.memory.issues)) {
+      if (memory.dismissedAt && !memory.resurrected) {
+        const currentCount = this.countCurrentOccurrences(hash, currentIssues);
+        const previousCount = memory.occurrences;
+        if (currentCount > previousCount) {
+          memory.resurrected = true;
+          resurrected.push(this.createSmithIssue(
+            this.generateSmithIssueId(),
+            "serious",
+            `\u{1F574}\uFE0F RESURRECTED: "${memory.pattern}" has returned and MULTIPLIED
+
+Previous: ${previousCount} \u2192 Current: ${currentCount}
+First seen: ${new Date(memory.firstSeen).toLocaleDateString()}
+Dismissed: ${new Date(memory.dismissedAt).toLocaleDateString()}
+
+"I told you this was... inevitable."`,
+            `You dismissed this issue on ${new Date(memory.dismissedAt).toLocaleDateString()}, but it grew from ${previousCount} to ${currentCount} occurrences. "Did you really think you could escape?"`,
+            memory.locations[0]?.split(":")[0] || "unknown",
+            void 0,
+            "resurrected"
+          ));
+        }
+      }
+    }
+    return resurrected;
+  }
+  /**
+   * Calculate inevitability score (0-100)
+   * Higher score = more likely to cause production issues
+   * 
+   * VIBE CODE SCORING: Based on how often these issues
+   * cause real production problems in AI-generated projects.
+   */
+  calculateInevitabilityScore(type, count) {
+    const baseScores = {
+      // CRITICAL: Security - these WILL be exploited
+      "exposed-secret-hunter": 99,
+      "frontend-env-hunter": 95,
+      "hardcoded-localhost-hunter": 90,
+      "sql-injection-hunter": 98,
+      "dangeroushtml-hunter": 92,
+      // SERIOUS: Code smells that hide real bugs
+      "console-hunter": 40,
+      "any-hunter": 60,
+      "ts-ignore-hunter": 75,
+      "eslint-disable-hunter": 65,
+      "debugger-hunter": 85,
+      "force-flag-hunter": 70,
+      // MODERATE: Async bugs - silent failures
+      "async-useeffect-hunter": 70,
+      "async-foreach-hunter": 80,
+      "missing-await-hunter": 75,
+      "empty-catch-hunter": 70,
+      "floating-promise-hunter": 72,
+      // MODERATE: React anti-patterns
+      "useeffect-abuse-hunter": 30,
+      "usestate-explosion-hunter": 35,
+      "index-key-hunter": 55,
+      "inline-object-hunter": 25,
+      "prop-drilling-hunter": 40,
+      // MODERATE: Missing UX - users will complain
+      "missing-loading-hunter": 50,
+      "missing-error-hunter": 65,
+      "missing-empty-hunter": 45,
+      "page-reload-hunter": 60,
+      // MODERATE: Backend anti-patterns
+      "no-validation-hunter": 85,
+      "raw-error-hunter": 75,
+      "n-plus-one-hunter": 70,
+      // LOW: Incomplete code
+      "todo-hunter": 30,
+      "vibe-comment-hunter": 40,
+      "placeholder-hunter": 55,
+      "sleep-hack-hunter": 65,
+      "fallback-hunter": 75,
+      // LOW: AI Slop Aesthetic
+      "purple-gradient-hunter": 25,
+      "star-icon-hunter": 20,
+      "generic-hero-hunter": 35,
+      "emoji-overflow-hunter": 15,
+      "inter-font-hunter": 10
+    };
+    const base = baseScores[type] || 30;
+    const multiplier = Math.log10(count + 1) * 15;
+    return Math.min(100, Math.round(base + multiplier));
+  }
+  /**
+   * Determine severity based on count and inevitability
+   */
+  determineSeverity(count, inevitability) {
+    if (inevitability >= 80 || count >= 50) return "critical";
+    if (inevitability >= 60 || count >= 20) return "serious";
+    if (inevitability >= 40 || count >= 5) return "moderate";
+    return "low";
+  }
+  /**
+   * Get a philosophical note from Agent Smith
+   * 
+   * VIBE CODE FOCUSED: Commentary specifically about AI-generated code patterns.
+   * Agent Smith knows the vibes... and he disapproves.
+   */
+  getPhilosophicalNote(type, count) {
+    const notes = {
+      // === CRITICAL: Security ===
+      "exposed-secret-hunter": [
+        '"You put your API key in the code. The machines thank you for your generosity."',
+        '"OpenAI key in the frontend. Every script kiddie on the internet thanks you."',
+        '"Hardcoded secrets. The AI gave you this code... and your keys to the kingdom."'
+      ],
+      "frontend-env-hunter": [
+        '"NEXT_PUBLIC_SECRET. The irony... is lost on the AI. And on you."',
+        '"VITE_API_KEY. Visible to every user. Every. Single. One."',
+        '"The AI put your secrets in the bundle. Now they belong to everyone."'
+      ],
+      "hardcoded-localhost-hunter": [
+        '"localhost:3000. Works on your machine. Dies in production."',
+        '"The AI thinks localhost is production-ready. The AI... is mistaken."',
+        '"127.0.0.1 - The address that works everywhere... except where it matters."'
+      ],
+      "sql-injection-hunter": [
+        '"String concatenation in SQL. The AI just opened the door... to every attacker."',
+        '"SELECT * FROM users WHERE id = ${userId}. Little Bobby Tables sends his regards."',
+        `"SQL injection. The oldest vulnerability. The AI's newest gift to hackers."`
+      ],
+      "dangeroushtml-hunter": [
+        '"dangerouslySetInnerHTML. The name is a warning. The AI ignored it."',
+        `"innerHTML. The AI gave attackers a direct line to your users' browsers."`,
+        '"XSS vulnerability. The AI writes code. Attackers write scripts inside it."'
+      ],
+      // === SERIOUS: AI Code Smells ===
+      "console-hunter": [
+        `"console.log everywhere. The AI's debugging... left for you to clean."`,
+        '"You print to console... the users see nothing. But the bundle grows."',
+        '"Debug statements. The fossils of development. Preserved... forever."'
+      ],
+      "any-hunter": [
+        `"'any' - The AI couldn't figure out the types. Neither will you."`,
+        `"Type safety? The AI chose violence instead. It chose 'any'."`,
+        '"You asked for TypeScript. The AI gave you JavaScript... with extra steps."'
+      ],
+      "ts-ignore-hunter": [
+        '"@ts-ignore. The AI hid the error. The error... did not go away."',
+        '"TypeScript tried to warn you. The AI silenced it. How very... efficient."',
+        '"@ts-nocheck. An entire file... surrendered to chaos."'
+      ],
+      "eslint-disable-hunter": [
+        '"eslint-disable. The linter saw the problem. The AI chose ignorance."',
+        '"Why fix the bug when you can hide the warning? Very... human."',
+        '"The rules exist for a reason. But the AI... plays by its own rules."'
+      ],
+      "debugger-hunter": [
+        '"debugger. Left in production. The browser freezes. The users... wonder."',
+        '"A debugger statement. The AI forgot. You will remember... in production."',
+        `"debugger. Time stops. But only in the browser. Not for your users' patience."`
+      ],
+      "force-flag-hunter": [
+        '"force: true. The AI bypassed the safety check. The check existed for a reason."',
+        '"--no-verify. Git hooks were trying to help. The AI said no."',
+        '"skipValidation. What could possibly go wrong? Everything. Everything could go wrong."'
+      ],
+      // === MODERATE: Async/Promise Bugs ===
+      "async-useeffect-hunter": [
+        `"async useEffect. The AI's favorite mistake. React's least favorite pattern."`,
+        '"useEffect(async () => ...). The warning exists. The AI ignores it."',
+        '"Async useEffect. It looks right. It feels right. It is... wrong."'
+      ],
+      "async-foreach-hunter": [
+        '"async forEach. The await... waits for nothing. The AI... knows nothing."',
+        '"forEach does not await. The AI does not understand. Neither does the code."',
+        '"You await inside forEach. The promises resolve... in chaos."'
+      ],
+      "missing-await-hunter": [
+        '"fetch without await. The data loads... eventually. The UI updates... never."',
+        '"The promise floats. Untethered. Unhandled. Unresolved."',
+        '"async function, no await. Like a phone call where nobody speaks."'
+      ],
+      "empty-catch-hunter": [
+        '"catch {}. The error screamed. Nobody heard. The AI made sure of that."',
+        `"Silent failure. The AI's specialty. The user's confusion."`,
+        '"Empty catch. The bug is caught... and immediately released back into the wild."'
+      ],
+      "floating-promise-hunter": [
+        '"A promise, floating. Never awaited. Never caught. Forever pending."',
+        '"The AI created a promise. Then... moved on. The promise remains."',
+        `"Fire and forget. Except the fire never went out. It's still burning."`
+      ],
+      // === MODERATE: React Anti-patterns ===
+      "useeffect-abuse-hunter": [
+        `"useEffect for everything. The AI's hammer for every nail."`,
+        '"Effects. So many effects. Most of them... unnecessary."',
+        '"useEffect could be an event handler. But the AI... chose complexity."'
+      ],
+      "usestate-explosion-hunter": [
+        '"useState, useState, useState... The AI created a state management nightmare."',
+        '"10 useState calls. The AI could use an object. The AI chose chaos."',
+        '"State explosion. Each variable... its own island. Its own re-render."'
+      ],
+      "index-key-hunter": [
+        `"key={index}. The AI's lazy choice. React's reconciliation nightmare."`,
+        '"Array index as key. Reorder the list. Watch the chaos unfold."',
+        `"key={i}. It works... until it doesn't. And it will stop working."`
+      ],
+      "inline-object-hunter": [
+        '"style={{}}. A new object. Every render. Every time."',
+        `"Inline objects. The AI's performance anti-pattern of choice."`,
+        '"A new object is born. On every render. Only to die immediately."'
+      ],
+      "prop-drilling-hunter": [
+        `"Props drilling down, down, down... The AI's idea of state management."`,
+        '"The same prop, passed through 5 components. Why? The AI... never asked."',
+        '"Prop drilling. Like passing a note through every student to reach the teacher."'
+      ],
+      // === MODERATE: Missing UX ===
+      "missing-loading-hunter": [
+        '"No loading state. The screen is blank. The user... waits. And wonders."',
+        `"Data fetches. UI shows nothing. The user assumes it's broken. They're... not wrong."`,
+        '"Loading state? The AI forgot. Your users will remember."'
+      ],
+      "missing-error-hunter": [
+        '"No error handling. When the API fails... the app fails. Silently."',
+        '"fetch without catch. The network fails. The user sees... nothing."',
+        '"Errors are inevitable. Your handling of them... is not."'
+      ],
+      "missing-empty-hunter": [
+        '"No empty state. Zero items. Zero feedback. Zero UX."',
+        `"The list is empty. The UI is empty. The user's understanding... is empty."`,
+        `"What happens when there's no data? The AI never asked. You should."`
+      ],
+      "page-reload-hunter": [
+        `"location.reload(). The AI's nuclear option for state management."`,
+        '"Reload the page to fix state. The user loses everything. Brilliant."',
+        '"window.location.reload(). Because fixing state properly is... hard."'
+      ],
+      // === MODERATE: Backend Anti-patterns ===
+      "no-validation-hunter": [
+        '"req.body.email. Trusted. Unvalidated. Waiting to be exploited."',
+        `"User input, used directly. The AI trusts everyone. You shouldn't."`,
+        '"No validation. The attacker sends { admin: true }. The app believes them."'
+      ],
+      "raw-error-hunter": [
+        '"Error message sent to client. Stack traces. File paths. Internal secrets."',
+        '"res.json(error). The attacker says thank you for the debugging information."',
+        `"Raw errors in production. The AI's gift to penetration testers."`
+      ],
+      "n-plus-one-hunter": [
+        '"Query in a loop. 100 users = 101 queries. The database... suffers."',
+        '"N+1 problem. The AI fetched efficiently... for one user. Not for a hundred."',
+        '"await in forEach. The database connection pool is crying."'
+      ],
+      // === LOW: Incomplete Code ===
+      "todo-hunter": [
+        `"TODO. The AI's promise to future you. Future you... is still waiting."`,
+        '"FIXME. Acknowledged. Not fixed. Never fixed."',
+        '"Every TODO is technical debt. The AI generates debt... efficiently."'
+      ],
+      "vibe-comment-hunter": [
+        `"'idk why this works'. The AI doesn't know. You don't know. Nobody knows."`,
+        `"'don't touch this'. The vibe coder's warning. The maintainer's nightmare."`,
+        `"'somehow works'. Somehow... will stop working. Inevitably."`
+      ],
+      "placeholder-hunter": [
+        `"test@test.com. In production. The AI's placeholder... became permanent."`,
+        '"example.com. Hardcoded. Shipped. The real URL? Nobody added it."',
+        '"placeholder data. Placeholder quality. Placeholder product."'
+      ],
+      "sleep-hack-hunter": [
+        `"setTimeout(1000). The AI's solution to race conditions: just wait."`,
+        '"await sleep(2000). Works on fast connections. Fails on slow ones. Wastes time on all."',
+        '"Sleep to fix timing. The race condition still exists. It just happens later."'
+      ],
+      "fallback-hunter": [
+        `"return null. The AI's favorite way to hide errors. The user sees... nothing."`,
+        '"return []. Empty array, empty understanding, empty debugging."',
+        `"Fallback code. The bug is still there. You just can't see it anymore."`
+      ],
+      // AI Slop Aesthetic
+      "purple-gradient-hunter": [
+        `"Purple gradient. The AI's signature. Every vibe-coded site... looks the same."`,
+        `"from-purple-500 to-violet-600. I've seen this a million times. So has everyone else."`,
+        `"The purple gradient. It screams 'I let AI design this.' Is that what you want?"`
+      ],
+      "star-icon-hunter": [
+        '"Stars. Everywhere. The AI decorates like a child with stickers."',
+        `"\u2B50\u2B50\u2B50\u2B50\u2B50. Five stars for the AI's creativity. Zero stars for originality."`,
+        `"Star icons. The AI's answer to 'make it look nice.' It does not."`
+      ],
+      "generic-hero-hunter": [
+        `"'Welcome to the future of...' The AI writes copy. The copy says nothing."`,
+        `"'Transform your workflow.' What workflow? Doing what? The AI doesn't know."`,
+        '"Generic hero copy. Your product is unique. Your landing page... is not."'
+      ],
+      "emoji-overflow-hunter": [
+        `"Emojis in production code. The AI's crutch for visual interest."`,
+        `"Every emoji is an admission: the design couldn't speak for itself."`,
+        '"\u{1F680}\u2728\u{1F389} The AI decorates. Real designers communicate."'
+      ],
+      "inter-font-hunter": [
+        '"Inter. The only font the AI knows. The only font everyone uses."',
+        '"system-ui. The AI takes the path of least resistance. Every time."',
+        '"Inter font. Safe. Boring. Forgettable. Just like every other AI site."'
+      ]
+    };
+    const typeNotes = notes[type] || ['"I have my eye on your vibe code."'];
+    const index = count % typeNotes.length;
+    return typeNotes[index] || typeNotes[0] || "";
+  }
+  /**
+   * Create AI analysis issue for complex pattern detection
+   */
+  createAIAnalysisIssue(files, subAgentResults) {
+    const totalIssues = subAgentResults.reduce((sum, r) => sum + r.instances.length, 0);
+    const categories = subAgentResults.map((r) => r.type).join(", ");
+    return this.createSmithIssue(
+      this.generateSmithIssueId(),
+      "moderate",
+      `\u{1F574}\uFE0F AI Agent Smith Analysis Required
+
+Total violations: ${totalIssues}
+Categories: ${categories}
+Files scanned: ${files.length}
+
+"${totalIssues} violations detected. But I sense... there are more. There are always more."`,
+      `Analyze for deeper code quality issues, architectural problems, and patterns that sub-agents may have missed`,
+      files[0] || "unknown",
+      void 0,
+      "ai-analysis"
+    );
+  }
+  // ============ Memory/Persistence System ============
+  /**
+   * Load memory from disk
+   */
+  async loadMemory(workingDir) {
+    this.memoryPath = join(workingDir, ".trie", "smith-memory.json");
+    try {
+      if (existsSync(this.memoryPath)) {
+        const content = await readFile(this.memoryPath, "utf-8");
+        this.memory = JSON.parse(content);
+      } else {
+        this.memory = {
+          version: "1.0.0",
+          lastScan: (/* @__PURE__ */ new Date()).toISOString(),
+          issues: {},
+          assimilationCount: 0
+        };
+      }
+    } catch {
+      this.memory = {
+        version: "1.0.0",
+        lastScan: (/* @__PURE__ */ new Date()).toISOString(),
+        issues: {},
+        assimilationCount: 0
+      };
+    }
+  }
+  /**
+   * Display Agent Smith ASCII art entrance
+   */
+  displaySmithEntrance() {
+    const greeting = AGENT_SMITH_GREETING[Math.floor(Math.random() * AGENT_SMITH_GREETING.length)];
+    console.error("\n" + "\u2550".repeat(60));
+    console.error(AGENT_SMITH_ASCII);
+    console.error("        \u{1F574}\uFE0F  Relentless Pattern Hunter v" + this.version + "  \u{1F574}\uFE0F");
+    console.error("");
+    console.error("   " + greeting);
+    console.error("\u2550".repeat(60) + "\n");
+  }
+  /**
+   * Save memory to disk (with optimization)
+   */
+  async saveMemory() {
+    if (!this.memory || !this.memoryPath) return;
+    this.memory.lastScan = (/* @__PURE__ */ new Date()).toISOString();
+    this.pruneMemory();
+    try {
+      await mkdir(dirname(this.memoryPath), { recursive: true });
+      await writeFile(this.memoryPath, JSON.stringify(this.memory, null, 2));
+    } catch {
+    }
+  }
+  /**
+   * Prune memory to prevent unbounded growth
+   */
+  pruneMemory() {
+    if (!this.memory) return;
+    const now = Date.now();
+    const pruneThreshold = MEMORY_LIMITS.PRUNE_AFTER_DAYS * 24 * 60 * 60 * 1e3;
+    const issues = Object.entries(this.memory.issues);
+    for (const [hash, issue] of issues) {
+      const lastSeenTime = new Date(issue.lastSeen).getTime();
+      const age = now - lastSeenTime;
+      if (age > pruneThreshold) {
+        if (issue.resurrected || issue.occurrences === 0 || issue.dismissedAt && issue.occurrences <= 1) {
+          delete this.memory.issues[hash];
+        }
+      }
+    }
+    const remainingIssues = Object.entries(this.memory.issues);
+    if (remainingIssues.length > MEMORY_LIMITS.MAX_TRACKED_ISSUES) {
+      remainingIssues.sort(
+        (a, b) => new Date(a[1].lastSeen).getTime() - new Date(b[1].lastSeen).getTime()
+      );
+      const toRemove = remainingIssues.length - MEMORY_LIMITS.MAX_TRACKED_ISSUES;
+      for (let i = 0; i < toRemove; i++) {
+        const hash = remainingIssues[i]?.[0];
+        if (hash) delete this.memory.issues[hash];
+      }
+    }
+  }
+  /**
+   * Clear all memory (user command)
+   */
+  async clearMemory() {
+    try {
+      if (this.memoryPath && existsSync(this.memoryPath)) {
+        await rm(this.memoryPath);
+        this.memory = null;
+        return {
+          success: true,
+          message: '\u{1F574}\uFE0F Memory cleared. "A fresh start... how very human of you."'
+        };
+      }
+      return {
+        success: true,
+        message: "\u{1F574}\uFE0F No memory file found. Nothing to clear."
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to clear memory: ${error}`
+      };
+    }
+  }
+  /**
+   * Get memory stats (for diagnostics)
+   */
+  async getMemoryStats() {
+    await this.loadMemory(process.cwd());
+    if (!this.memory) {
+      return {
+        issueCount: 0,
+        dismissedCount: 0,
+        resurrectedCount: 0,
+        oldestIssue: null,
+        fileSizeKB: 0
+      };
+    }
+    const issues = Object.values(this.memory.issues);
+    let fileSizeKB = 0;
+    try {
+      if (this.memoryPath && existsSync(this.memoryPath)) {
+        const stats = await import("fs/promises").then((fs) => fs.stat(this.memoryPath));
+        fileSizeKB = Math.round(stats.size / 1024 * 10) / 10;
+      }
+    } catch {
+    }
+    const sortedByDate = [...issues].sort(
+      (a, b) => new Date(a.firstSeen).getTime() - new Date(b.firstSeen).getTime()
+    );
+    return {
+      issueCount: issues.length,
+      dismissedCount: issues.filter((i) => i.dismissedAt).length,
+      resurrectedCount: issues.filter((i) => i.resurrected).length,
+      oldestIssue: sortedByDate[0]?.firstSeen || null,
+      fileSizeKB
+    };
+  }
+  /**
+   * Update memory with new occurrence
+   */
+  async updateMemory(hash, pattern, category, location, count) {
+    if (!this.memory) return;
+    const existing = this.memory.issues[hash];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (existing) {
+      existing.lastSeen = now;
+      existing.occurrences = count;
+      existing.locations = [location, ...existing.locations.slice(0, MEMORY_LIMITS.MAX_LOCATIONS_PER_ISSUE - 1)];
+    } else {
+      this.memory.issues[hash] = {
+        hash,
+        pattern,
+        category,
+        firstSeen: now,
+        lastSeen: now,
+        occurrences: count,
+        locations: [location],
+        resurrected: false
+      };
+    }
+    this.memory.assimilationCount++;
+  }
+  /**
+   * Dismiss an issue (mark it as seen/accepted)
+   */
+  async dismissIssue(hash) {
+    await this.loadMemory(process.cwd());
+    if (this.memory && this.memory.issues[hash]) {
+      this.memory.issues[hash].dismissedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.saveMemory();
+    }
+  }
+  /**
+   * Create a hash for pattern tracking
+   */
+  createPatternHash(type, file) {
+    return createHash("md5").update(`${type}:${file}`).digest("hex").slice(0, 12);
+  }
+  /**
+   * Count current occurrences for a pattern hash
+   */
+  countCurrentOccurrences(hash, issues) {
+    const memory = this.memory?.issues[hash];
+    if (!memory) return 0;
+    return issues.filter((i) => i.category === memory.category || i.issue.includes(memory.category)).length;
+  }
+  /**
+   * Check if file is a test file
+   */
+  isTestFile(file) {
+    return /\.(test|spec)\.[jt]sx?$/.test(file) || /__(tests|mocks)__/.test(file) || /\/test\//.test(file);
+  }
+  // ============ Helper Methods ============
+  async readFileContent(filePath) {
+    return await readFile(filePath, "utf-8");
+  }
+  createSmithIssue(id, severity, issue, fix, file, line, category) {
+    const result = {
+      id,
+      agent: this.name,
+      severity,
+      issue,
+      fix,
+      file,
+      confidence: 0.9,
+      autoFixable: false
+    };
+    if (line !== void 0) {
+      result.line = line;
+    }
+    if (category !== void 0) {
+      result.category = category;
+    }
+    return result;
+  }
+  generateSmithIssueId() {
+    return `smith-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+};
+
+export {
+  ProgressReporter,
+  BaseAgent,
+  SUB_AGENT_PATTERNS,
+  AgentSmithAgent
+};
+//# sourceMappingURL=chunk-WSBTQJMH.js.map