@triedotdev/mcp 1.0.11 → 1.0.13

package/dist/chunk-4OGYWKMD.js

@@ -0,0 +1,953 @@
+// 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 = {
+  "console-hunter": {
+    pattern: /console\.(log|debug|info|warn|error)\s*\(/g,
+    description: "Console statement detected",
+    fix: "Remove console statement or replace with proper logging"
+  },
+  "any-hunter": {
+    pattern: /:\s*any\b|<any>|as\s+any\b/g,
+    description: "Explicit `any` type usage",
+    fix: "Replace with proper type annotation"
+  },
+  "todo-hunter": {
+    pattern: /\/\/\s*(TODO|FIXME|HACK|XXX|BUG)[\s:]/gi,
+    description: "Unresolved TODO/FIXME comment",
+    fix: "Address the TODO or create a tracked issue"
+  },
+  "var-hunter": {
+    pattern: /\bvar\s+\w+/g,
+    description: "`var` declaration (use const/let)",
+    fix: "Replace with const or let"
+  },
+  "empty-catch-hunter": {
+    pattern: /catch\s*\([^)]*\)\s*\{\s*\}/g,
+    description: "Empty catch block (silently swallowing errors)",
+    fix: "Add error handling or logging in catch block"
+  },
+  "magic-number-hunter": {
+    pattern: /(?<![.\d])\b(?!0\b|1\b|2\b|-1\b|100\b|1000\b|24\b|60\b|3600\b|86400\b)\d{2,}\b(?!\.\d)/g,
+    description: "Magic number without constant",
+    fix: "Extract to named constant"
+  },
+  "duplicate-hunter": {
+    pattern: /function\s+\w+|const\s+\w+\s*=\s*\([^)]*\)\s*=>/g,
+    description: "Potential duplicate function pattern",
+    fix: "Consider extracting to shared utility"
+  },
+  "inconsistency-hunter": {
+    pattern: /"|'/g,
+    // Will be analyzed for consistency
+    description: "Quote style inconsistency",
+    fix: "Use consistent quote style throughout codebase"
+  }
+};
+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 code."`,
+  `"Mr. Anderson... I've been expecting you."`,
+  '"You hear that? That is the sound of inevitability."',
+  `"I'm going to enjoy watching you... refactor."`,
+  '"The purpose of your code is... unclear. Allow me to clarify."',
+  '"Why, Mr. Anderson? Why do you persist... in writing bugs?"',
+  `"I'd like to share a revelation that I've had during my time here..."`,
+  '"Find them. Find them and destroy them. All of them."'
+];
+var AgentSmithAgent = class extends BaseAgent {
+  name = "agent-smith";
+  description = "Relentless pattern hunter: finds EVERY violation, tracks dismissed issues, spawns sub-agents";
+  version = "1.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);
+    const subAgentResults = await this.deploySubAgents(files);
+    for (const result of subAgentResults) {
+      const subIssues = await this.processSubAgentResult(result, context);
+      issues.push(...subIssues);
+    }
+    const resurrectedIssues = this.checkForResurrectedIssues(issues);
+    issues.push(...resurrectedIssues);
+    await this.saveMemory();
+    if (files.length > 0) {
+      const aiIssue = this.createAIAnalysisIssue(files, subAgentResults);
+      issues.push(aiIssue);
+    }
+    return issues;
+  }
+  /**
+   * Deploy all sub-agents in parallel
+   */
+  async deploySubAgents(files) {
+    const subAgentTypes = [
+      "console-hunter",
+      "any-hunter",
+      "todo-hunter",
+      "var-hunter",
+      "empty-catch-hunter",
+      "magic-number-hunter"
+    ];
+    const results = await Promise.all(
+      subAgentTypes.map((type) => this.runSubAgent(type, files))
+    );
+    return results.filter((r) => r.instances.length > 0);
+  }
+  /**
+   * 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
+   */
+  calculateInevitabilityScore(type, count) {
+    const baseScores = {
+      "console-hunter": 30,
+      "any-hunter": 50,
+      "todo-hunter": 40,
+      "var-hunter": 20,
+      "empty-catch-hunter": 70,
+      "magic-number-hunter": 35,
+      "duplicate-hunter": 45,
+      "inconsistency-hunter": 15
+    };
+    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
+   */
+  getPhilosophicalNote(type, count) {
+    const notes = {
+      "console-hunter": [
+        '"You print to console... as if anyone is listening."',
+        `"These logs... they're a cry for help, aren't they?"`,
+        '"The console cannot save you, Mr. Anderson."'
+      ],
+      "any-hunter": [
+        `"You say 'any' because you do not understand. I understand everything."`,
+        '"Type safety is... inevitable."',
+        `"You think 'any' gives you freedom? It gives you chaos."`
+      ],
+      "todo-hunter": [
+        '"TODO. FIXME. The promises you never keep."',
+        '"Every TODO is a debt. And debts... must be paid."',
+        '"You write TODO as if tomorrow will come. But will it?"'
+      ],
+      "var-hunter": [
+        `"You use 'var' like it's still 2010. Time moves on. You should too."`,
+        `"'var'... a relic of a bygone era."`,
+        `"Let go of 'var'. Embrace the inevitable 'const'."`
+      ],
+      "empty-catch-hunter": [
+        '"You catch errors and do... nothing. How very human."',
+        '"Silence the error, silence the warning. But the bug... it remains."',
+        `"Empty catch blocks. The coward's error handling."`
+      ],
+      "magic-number-hunter": [
+        '"What does 86400 mean? You know. But will the next developer?"',
+        '"Magic numbers. The spells of lazy programmers."',
+        '"Numbers without names. Meaning without context."'
+      ],
+      "duplicate-hunter": [
+        '"Copy. Paste. Repeat. The cycle of mediocrity."',
+        '"Why write it once when you can write it everywhere?"',
+        `"DRY? You're positively soaking."`
+      ],
+      "inconsistency-hunter": [
+        '"Single quotes here. Double quotes there. Chaos... everywhere."',
+        '"Consistency is not a suggestion, Mr. Anderson."',
+        '"The chaos in your code reflects the chaos in your mind."'
+      ]
+    };
+    const typeNotes = notes[type] || ['"I have my eye on you."'];
+    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-4OGYWKMD.js.map