@triedotdev/mcp 1.0.58 → 1.0.60

package/dist/{chunk-6ODT4U4O.js → chunk-C7LXN754.js}

@@ -1,170 +1,10 @@
 import {
   getWorkingDirectory
 } from "./chunk-ASGSTVVF.js";
-
-// src/utils/progress.ts
-var _interactiveMode = false;
-function setInteractiveMode(enabled) {
-  _interactiveMode = enabled;
-}
-function isInteractiveMode() {
-  return _interactiveMode;
-}
-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 || _interactiveMode) 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) {
-    if (_interactiveMode) return;
-    const prefix = "[AI]";
-    const message = context ? `${action}: ${context}` : action;
-    console.error(`${prefix} ${message}`);
-  }
-  /**
-   * Report a finding
-   */
-  finding(severity, message) {
-    if (_interactiveMode) return;
-    const labels = {
-      critical: "[CRITICAL]",
-      serious: "[SERIOUS]",
-      moderate: "[MODERATE]",
-      low: "[LOW]"
-    };
-    console.error(`   ${labels[severity]} ${message}`);
-  }
-  /**
-   * Complete current phase
-   */
-  completePhase(summary) {
-    const elapsed = Date.now() - this.phaseStartTime;
-    this.report(`Done: ${summary}`, `(${elapsed}ms)`);
-  }
-  /**
-   * Complete the entire operation
-   */
-  complete(summary) {
-    if (_interactiveMode) return;
-    const totalElapsed = Date.now() - this.startTime;
-    console.error("");
-    console.error(`----------------------------------------`);
-    console.error(`[COMPLETE] ${summary}`);
-    console.error(`   Total time: ${(totalElapsed / 1e3).toFixed(2)}s`);
-    console.error(`----------------------------------------`);
-    console.error("");
-  }
-  /**
-   * Report an error
-   */
-  error(message, detail) {
-    if (_interactiveMode) return;
-    const fullMessage = detail ? `${message}: ${detail}` : message;
-    console.error(`[ERROR] ${fullMessage}`);
-  }
-  /**
-   * Report a warning
-   */
-  warn(message, detail) {
-    if (_interactiveMode) return;
-    const fullMessage = detail ? `${message}: ${detail}` : message;
-    console.error(`[WARN] ${fullMessage}`);
-  }
-  /**
-   * Get icon for current phase
-   */
-  getPhaseIcon(phase) {
-    const icons = {
-      "init": ">>",
-      "discovery": ">>",
-      "reading": ">>",
-      "analyzing": ">>",
-      "ai-review": "[AI]",
-      "prioritizing": ">>",
-      "complete": "[OK]"
-    };
-    return icons[phase] || ">>";
-  }
-  /**
-   * 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 || _interactiveMode) return;
-    console.error(`
-[AGENT] ${this.agentName.toUpperCase()} starting...`);
-  }
-  analyzing(file) {
-    if (!this.verbose || _interactiveMode) return;
-    const fileName = file.split("/").pop() || file;
-    console.error(`   Analyzing ${fileName}...`);
-  }
-  aiReview(context) {
-    if (!this.verbose || _interactiveMode) return;
-    console.error(`   [AI] reviewing: ${context}`);
-  }
-  found(severity, issue) {
-    this.issueCount++;
-    if (!this.verbose || _interactiveMode) return;
-    const label = severity === "critical" ? "[CRITICAL]" : severity === "serious" ? "[SERIOUS]" : severity === "moderate" ? "[MODERATE]" : "[LOW]";
-    console.error(`   ${label} Found: ${issue}`);
-  }
-  complete(summary) {
-    if (!this.verbose || _interactiveMode) return;
-    const msg = summary || `Found ${this.issueCount} issues`;
-    console.error(`   Done: ${this.agentName}: ${msg}`);
-  }
-  getIssueCount() {
-    return this.issueCount;
-  }
-};
+import {
+  AgentProgressReporter,
+  isInteractiveMode
+} from "./chunk-RAZUNSBI.js";
 
 // src/skills/built-in/base-skill.ts
 import { relative } from "path";
@@ -635,6 +475,518 @@ import { readFile, writeFile, mkdir, rm } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { join as join2, dirname, basename } from "path";
 import { createHash } from "crypto";
+
+// src/utils/output-manager.ts
+import pc from "picocolors";
+var OutputManagerImpl = class {
+  mode = "console";
+  streamingManager;
+  markdownBuffer = [];
+  jsonBuffer = [];
+  rawLogBuffer = [];
+  // Callbacks for TUI integration (explicitly allow undefined for exactOptionalPropertyTypes)
+  onBanner = void 0;
+  onSnippet = void 0;
+  onCost = void 0;
+  onReadiness = void 0;
+  onSemantic = void 0;
+  onAttack = void 0;
+  onActivity = void 0;
+  onLog = void 0;
+  /**
+   * Set the output mode
+   */
+  setMode(mode) {
+    this.mode = mode;
+  }
+  /**
+   * Get current output mode
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Set streaming manager for TUI updates
+   */
+  setStreamingManager(manager) {
+    this.streamingManager = manager;
+  }
+  /**
+   * Register TUI callbacks for rich content
+   */
+  registerTUICallbacks(callbacks) {
+    this.onBanner = callbacks.onBanner;
+    this.onSnippet = callbacks.onSnippet;
+    this.onCost = callbacks.onCost;
+    this.onReadiness = callbacks.onReadiness;
+    this.onSemantic = callbacks.onSemantic;
+    this.onAttack = callbacks.onAttack;
+    this.onActivity = callbacks.onActivity;
+    this.onLog = callbacks.onLog;
+  }
+  /**
+   * Clear TUI callbacks (when dashboard stops)
+   */
+  clearTUICallbacks() {
+    this.onBanner = void 0;
+    this.onSnippet = void 0;
+    this.onCost = void 0;
+    this.onReadiness = void 0;
+    this.onSemantic = void 0;
+    this.onAttack = void 0;
+    this.onActivity = void 0;
+    this.onLog = void 0;
+  }
+  /**
+   * Emit content - routes to appropriate handler based on mode
+   */
+  emit(content) {
+    content.timestamp = content.timestamp ?? Date.now();
+    switch (this.mode) {
+      case "tui":
+        this.routeToTUI(content);
+        break;
+      case "console":
+        this.routeToConsole(content);
+        break;
+      case "mcp":
+        this.routeToMarkdown(content);
+        break;
+      case "json":
+        this.routeToJson(content);
+        break;
+      case "silent":
+        break;
+    }
+    this.captureRawLog(content);
+  }
+  /**
+   * Route content to TUI (dashboard callbacks)
+   */
+  routeToTUI(content) {
+    switch (content.type) {
+      case "banner":
+        this.onBanner?.(content.content);
+        break;
+      case "snippet":
+        this.onSnippet?.(content.content);
+        break;
+      case "cost":
+        this.onCost?.(content.content);
+        break;
+      case "readiness":
+        this.onReadiness?.(content.content);
+        break;
+      case "semantic":
+        this.onSemantic?.(content.content);
+        break;
+      case "attack":
+        this.onAttack?.(content.content);
+        break;
+      case "activity":
+        this.onActivity?.(content.content);
+        break;
+      case "log":
+        const level = content.metadata?.severity ?? "info";
+        this.onLog?.(level, content.content);
+        break;
+      case "issue":
+        this.streamingManager?.reportIssue(content.content);
+        break;
+      case "progress":
+        break;
+      case "report":
+        break;
+    }
+  }
+  /**
+   * Route content to console (ANSI formatted)
+   */
+  routeToConsole(content) {
+    switch (content.type) {
+      case "banner":
+        const banner = content.content;
+        console.error("\n" + "=".repeat(60));
+        console.error(banner.art);
+        if (banner.version) {
+          console.error(`        ${banner.skill} v${banner.version}`);
+        }
+        console.error("");
+        if (banner.quote) {
+          console.error(`   "${banner.quote}"`);
+        }
+        console.error("=".repeat(60) + "\n");
+        break;
+      case "snippet":
+        const snippet = content.content;
+        console.error(`
+${pc.dim("File:")} ${snippet.file}`);
+        for (let i = 0; i < snippet.lines.length; i++) {
+          const lineNum = snippet.startLine + i;
+          const isHighlight = lineNum === snippet.highlightLine;
+          const prefix = isHighlight ? pc.red("\u2192") : " ";
+          const lineNumStr = pc.dim(lineNum.toString().padStart(4));
+          const line = isHighlight ? pc.yellow(snippet.lines[i]) : snippet.lines[i];
+          console.error(`${prefix} ${lineNumStr} | ${line}`);
+        }
+        console.error("");
+        break;
+      case "cost":
+        const cost = content.content;
+        console.error("\n" + pc.cyan("\u{1F4B0} Cost Estimate:"));
+        console.error(`   Fix now: ${pc.green(this.formatCurrency(cost.fixNowCost))}`);
+        console.error(`   If production: ${pc.red(this.formatCurrency(cost.productionCost))}`);
+        console.error(`   Savings: ${pc.yellow(this.formatCurrency(cost.savings))}`);
+        console.error("");
+        break;
+      case "readiness":
+        const readiness = content.content;
+        const statusColor = readiness.status === "ready" ? pc.green : readiness.status === "caution" ? pc.yellow : pc.red;
+        console.error("\n" + pc.cyan("\u{1F4CA} Production Readiness:"));
+        console.error(`   Score: ${statusColor(readiness.score + "/100")}`);
+        console.error(`   Requirements: ${readiness.requirementsMet}/${readiness.total}`);
+        console.error(`   Status: ${statusColor(readiness.status.toUpperCase())}`);
+        console.error("");
+        break;
+      case "semantic":
+        const semantic = content.content;
+        console.error("\n" + pc.cyan("\u{1F50D} Semantic Analysis:"));
+        if (semantic.dataFlowIssues > 0) {
+          console.error(`   ${pc.red("[!]")} ${semantic.dataFlowIssues} data flow vulnerabilities`);
+        }
+        if (semantic.raceConditions > 0) {
+          console.error(`   ${pc.yellow("[~]")} ${semantic.raceConditions} race conditions`);
+        }
+        if (semantic.authIssues > 0) {
+          console.error(`   ${pc.red("[!]")} ${semantic.authIssues} authentication issues`);
+        }
+        console.error("");
+        break;
+      case "attack":
+        const attack = content.content;
+        console.error("\n" + pc.cyan("\u{1F3AF} Attack Surface:"));
+        console.error(`   Endpoints: ${attack.totalEndpoints}`);
+        if (attack.unprotected > 0) {
+          console.error(`   ${pc.red("Unprotected:")} ${attack.unprotected}`);
+        }
+        console.error(`   Risk Score: ${attack.riskScore}/100`);
+        console.error("");
+        break;
+      case "activity":
+        console.error(pc.dim(`[${this.formatTime()}]`) + ` ${content.content}`);
+        break;
+      case "log":
+        const logLevel = String(content.metadata?.severity ?? "info");
+        const levelColor = logLevel === "error" || logLevel === "critical" ? pc.red : logLevel === "warn" || logLevel === "serious" ? pc.yellow : logLevel === "info" || logLevel === "moderate" ? pc.blue : pc.dim;
+        console.error(levelColor(`[${logLevel.toUpperCase()}]`) + ` ${content.content}`);
+        break;
+      case "issue":
+        const issue = content.content;
+        const sevColor = issue.severity === "critical" ? pc.red : issue.severity === "serious" ? pc.yellow : issue.severity === "moderate" ? pc.blue : pc.dim;
+        console.error(`${sevColor(`[${issue.severity.toUpperCase()}]`)} ${issue.issue}`);
+        console.error(`   ${pc.dim("File:")} ${issue.file}:${issue.line ?? "?"}`);
+        break;
+      case "report":
+        console.error(content.content);
+        break;
+    }
+  }
+  /**
+   * Route content to markdown buffer
+   */
+  routeToMarkdown(content) {
+    switch (content.type) {
+      case "banner":
+        const banner = content.content;
+        this.markdownBuffer.push(`## ${banner.skill}
+`);
+        if (banner.quote) {
+          this.markdownBuffer.push(`> ${banner.quote}
+`);
+        }
+        break;
+      case "snippet":
+        const snippet = content.content;
+        this.markdownBuffer.push(`
+**File:** \`${snippet.file}\`
+`);
+        this.markdownBuffer.push("```\n");
+        for (let i = 0; i < snippet.lines.length; i++) {
+          const lineNum = snippet.startLine + i;
+          const prefix = lineNum === snippet.highlightLine ? "\u2192" : " ";
+          this.markdownBuffer.push(`${prefix} ${lineNum.toString().padStart(4)} | ${snippet.lines[i]}
+`);
+        }
+        this.markdownBuffer.push("```\n");
+        break;
+      case "cost":
+        const cost = content.content;
+        this.markdownBuffer.push(`
+### Cost Estimate
+`);
+        this.markdownBuffer.push(`- Fix now: ${this.formatCurrency(cost.fixNowCost)}
+`);
+        this.markdownBuffer.push(`- If production: ${this.formatCurrency(cost.productionCost)}
+`);
+        this.markdownBuffer.push(`- Savings: ${this.formatCurrency(cost.savings)}
+`);
+        break;
+      case "readiness":
+        const readiness = content.content;
+        this.markdownBuffer.push(`
+### Production Readiness
+`);
+        this.markdownBuffer.push(`- Score: ${readiness.score}/100
+`);
+        this.markdownBuffer.push(`- Requirements: ${readiness.requirementsMet}/${readiness.total}
+`);
+        this.markdownBuffer.push(`- Status: **${readiness.status.toUpperCase()}**
+`);
+        break;
+      case "semantic":
+        const semantic = content.content;
+        this.markdownBuffer.push(`
+### Semantic Analysis
+`);
+        if (semantic.dataFlowIssues > 0) {
+          this.markdownBuffer.push(`- [CRITICAL] ${semantic.dataFlowIssues} data flow vulnerabilities
+`);
+        }
+        if (semantic.raceConditions > 0) {
+          this.markdownBuffer.push(`- [WARN] ${semantic.raceConditions} race conditions
+`);
+        }
+        if (semantic.authIssues > 0) {
+          this.markdownBuffer.push(`- [CRITICAL] ${semantic.authIssues} authentication issues
+`);
+        }
+        break;
+      case "attack":
+        const attack = content.content;
+        this.markdownBuffer.push(`
+### Attack Surface
+`);
+        this.markdownBuffer.push(`- Endpoints: ${attack.totalEndpoints}
+`);
+        this.markdownBuffer.push(`- Unprotected: ${attack.unprotected}
+`);
+        this.markdownBuffer.push(`- Risk Score: ${attack.riskScore}/100
+`);
+        break;
+      case "report":
+        this.markdownBuffer.push(content.content);
+        break;
+      default:
+        this.jsonBuffer.push(content);
+    }
+  }
+  /**
+   * Route content to JSON buffer
+   */
+  routeToJson(content) {
+    this.jsonBuffer.push(content);
+  }
+  /**
+   * Capture content in raw log buffer
+   */
+  captureRawLog(content) {
+    const time = this.formatTime(content.timestamp);
+    const level = content.metadata?.severity ?? content.type;
+    let message = "";
+    switch (content.type) {
+      case "banner":
+        message = `[BANNER] ${content.content.skill}`;
+        break;
+      case "activity":
+      case "log":
+        message = content.content;
+        break;
+      case "issue":
+        const issue = content.content;
+        message = `[${issue.severity.toUpperCase()}] ${issue.issue}`;
+        break;
+      default:
+        message = `[${content.type.toUpperCase()}] Content received`;
+    }
+    this.rawLogBuffer.push({ time, level, message });
+    if (this.rawLogBuffer.length > 500) {
+      this.rawLogBuffer = this.rawLogBuffer.slice(-500);
+    }
+  }
+  /**
+   * Get raw log buffer for display
+   */
+  getRawLog() {
+    return [...this.rawLogBuffer];
+  }
+  /**
+   * Get accumulated markdown output
+   */
+  getMarkdown() {
+    return this.markdownBuffer.join("\n");
+  }
+  /**
+   * Get accumulated JSON output
+   */
+  getJson() {
+    return [...this.jsonBuffer];
+  }
+  /**
+   * Clear buffers
+   */
+  clearBuffers() {
+    this.markdownBuffer = [];
+    this.jsonBuffer = [];
+  }
+  // ============================================
+  // Convenience methods for common output types
+  // ============================================
+  /**
+   * Display a skill banner
+   */
+  banner(skill, art, options) {
+    this.emit({
+      type: "banner",
+      content: { skill, art, quote: options?.quote, version: options?.version },
+      metadata: { agent: skill }
+    });
+  }
+  /**
+   * Display a code snippet
+   */
+  snippet(file, lines, startLine, highlightLine) {
+    this.emit({
+      type: "snippet",
+      content: { file, lines, startLine, highlightLine },
+      metadata: { file }
+    });
+  }
+  /**
+   * Display cost estimate
+   */
+  cost(fixNowCost, productionCost, savings, perIssue) {
+    this.emit({
+      type: "cost",
+      content: { fixNowCost, productionCost, savings, perIssue }
+    });
+  }
+  /**
+   * Display production readiness
+   */
+  readiness(score, requirementsMet, total, status) {
+    this.emit({
+      type: "readiness",
+      content: { score, requirementsMet, total, status }
+    });
+  }
+  /**
+   * Display semantic analysis results
+   */
+  semantic(dataFlowIssues, raceConditions, authIssues) {
+    this.emit({
+      type: "semantic",
+      content: { dataFlowIssues, raceConditions, authIssues }
+    });
+  }
+  /**
+   * Display attack surface analysis
+   */
+  attack(totalEndpoints, unprotected, riskScore) {
+    this.emit({
+      type: "attack",
+      content: { totalEndpoints, unprotected, riskScore }
+    });
+  }
+  /**
+   * Log an activity message
+   */
+  activity(message) {
+    this.emit({
+      type: "activity",
+      content: message
+    });
+  }
+  /**
+   * Log a message at specified level
+   */
+  log(level, message) {
+    this.emit({
+      type: "log",
+      content: message,
+      metadata: { severity: level }
+    });
+  }
+  /**
+   * Log info message
+   */
+  info(message) {
+    this.log("info", message);
+  }
+  /**
+   * Log warning message
+   */
+  warn(message) {
+    this.log("warn", message);
+  }
+  /**
+   * Log error message
+   */
+  error(message) {
+    this.log("error", message);
+  }
+  /**
+   * Log debug message
+   */
+  debug(message) {
+    this.log("debug", message);
+  }
+  /**
+   * Report an issue
+   */
+  issue(issue) {
+    this.emit({
+      type: "issue",
+      content: issue,
+      metadata: { severity: issue.severity, agent: issue.agent, file: issue.file }
+    });
+  }
+  /**
+   * Add a report section
+   */
+  report(content) {
+    this.emit({
+      type: "report",
+      content
+    });
+  }
+  // ============================================
+  // Helpers
+  // ============================================
+  formatCurrency(amount) {
+    if (amount >= 1e6) return `$${(amount / 1e6).toFixed(2)}M`;
+    if (amount >= 1e3) return `$${(amount / 1e3).toFixed(1)}k`;
+    return `$${amount}`;
+  }
+  formatTime(timestamp) {
+    const date = timestamp ? new Date(timestamp) : /* @__PURE__ */ new Date();
+    return date.toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  }
+};
+var instance = null;
+function getOutputManager() {
+  if (!instance) {
+    instance = new OutputManagerImpl();
+    if (isInteractiveMode()) {
+      instance.setMode("tui");
+    }
+  }
+  return instance;
+}
+function output() {
+  return getOutputManager();
+}
+
+// src/skills/built-in/agent-smith.ts
 var MEMORY_LIMITS = {
   MAX_LOCATIONS_PER_ISSUE: 5,
   MAX_TRACKED_ISSUES: 500,
@@ -917,17 +1269,16 @@ var AgentSmithSkill = class extends BaseSkill {
     const loadedFiles = Array.from(fileContents.keys());
     this.displaySmithEntrance();
     await this.loadMemory(context.workingDir);
-    console.error(`
-[SMITH] Deploying sub-agent swarm across ${loadedFiles.length} files...`);
+    output().activity(`[SMITH] Deploying sub-agent swarm across ${loadedFiles.length} files...`);
     const subAgentResults = await this.deploySubAgents(loadedFiles, fileContents);
-    if (this.swarmAnimationLog.length > 0) {
-      console.error(this.swarmAnimationLog.join("\n"));
+    for (const line of this.swarmAnimationLog) {
+      output().activity(line);
     }
     for (const result of subAgentResults) {
       const subIssues = await this.processSubAgentResult(result, context);
       issues.push(...subIssues);
     }
-    console.error(`[SMITH] Analyzing file-level metrics...`);
+    output().activity(`[SMITH] Analyzing file-level metrics...`);
     const fileLevelResults = await this.analyzeFileLevelIssues(fileContents);
     for (const result of fileLevelResults) {
       for (const fileIssue of result.issues) {
@@ -942,7 +1293,7 @@ var AgentSmithSkill = class extends BaseSkill {
         ));
       }
     }
-    console.error(`[SMITH] Detecting cross-file patterns...`);
+    output().activity(`[SMITH] Detecting cross-file patterns...`);
     const crossFileResults = this.analyzeCrossFilePatterns(subAgentResults);
     for (const result of crossFileResults) {
       issues.push(this.createSmithIssue(
@@ -962,9 +1313,7 @@ var AgentSmithSkill = class extends BaseSkill {
       const aiIssue = this.createAIAnalysisIssue(loadedFiles, subAgentResults);
       issues.push(aiIssue);
     }
-    console.error(`
-[SMITH] Hunt complete. ${issues.length} violations found.
-`);
+    output().activity(`[SMITH] Hunt complete. ${issues.length} violations found.`);
     return issues;
   }
   /**
@@ -1069,8 +1418,8 @@ var AgentSmithSkill = class extends BaseSkill {
     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);
+      for (const instance2 of result.instances) {
+        byFile.set(instance2.file, (byFile.get(instance2.file) || 0) + 1);
       }
       if (byFile.size >= 5) {
         const occurrences = Array.from(byFile.entries()).map(([file, count]) => ({ file, count }));
@@ -1152,13 +1501,11 @@ var AgentSmithSkill = class extends BaseSkill {
       "emoji-overflow-hunter",
       "inter-font-hunter"
     ];
-    console.error(`   Deploying ${subAgentTypes.length} specialized hunters across ${files.length} files...`);
+    output().activity(`   Deploying ${subAgentTypes.length} specialized hunters across ${files.length} files...`);
     const { results, animationLog } = await this.runAgentSwarm(subAgentTypes, fileContents);
     this.swarmAnimationLog = animationLog;
     const activeHunters = results.filter((r) => r.instances.length > 0);
-    console.error(`
-   >> ${activeHunters.length} hunters found targets. Violations acquired.
-`);
+    output().activity(`   >> ${activeHunters.length} hunters found targets. Violations acquired.`);
     return activeHunters;
   }
   /**
@@ -1257,10 +1604,10 @@ var AgentSmithSkill = class extends BaseSkill {
     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 instance2 of result.instances) {
+      const existing = byFile.get(instance2.file) || [];
+      existing.push(instance2);
+      byFile.set(instance2.file, existing);
     }
     for (const [file, instances] of byFile) {
       const inevitabilityScore = this.calculateInevitabilityScore(result.type, instances.length);
@@ -1668,15 +2015,14 @@ ${config.fix}`;
   }
   /**
    * Display Agent Smith ASCII art entrance
+   * Uses OutputManager to route to TUI or console based on mode
    */
   displaySmithEntrance() {
-    const greeting = AGENT_SMITH_GREETING[Math.floor(Math.random() * AGENT_SMITH_GREETING.length)];
-    console.error("\n" + "=".repeat(60));
-    console.error(AGENT_SMITH_ASCII);
-    console.error("        Relentless Pattern Hunter v" + this.version);
-    console.error("");
-    console.error('   "' + greeting + '"');
-    console.error("=".repeat(60) + "\n");
+    const greeting = AGENT_SMITH_GREETING[Math.floor(Math.random() * AGENT_SMITH_GREETING.length)] ?? "The code will be... assimilated.";
+    output().banner("agent-smith", AGENT_SMITH_ASCII, {
+      quote: greeting,
+      version: this.version
+    });
   }
   /**
    * Save memory to disk (with optimization)
@@ -1880,14 +2226,13 @@ ${config.fix}`;
 };
 
 export {
-  setInteractiveMode,
-  isInteractiveMode,
-  ProgressReporter,
   isAIAvailable,
   runAIAnalysis,
   getAIStatusMessage,
   BaseSkill,
+  getOutputManager,
+  output,
   SUB_AGENT_PATTERNS,
   AgentSmithSkill
 };
-//# sourceMappingURL=chunk-6ODT4U4O.js.map
+//# sourceMappingURL=chunk-C7LXN754.js.map