@triedotdev/mcp 1.0.169 → 1.0.171

package/dist/chunk-AHD2CBQ7.js

@@ -1,846 +0,0 @@
-import {
-  getStorage
-} from "./chunk-BUTOP5EB.js";
-import {
-  tryGetClient
-} from "./chunk-FQ45QP5A.js";
-import {
-  searchIssues
-} from "./chunk-KCUOWRPX.js";
-import {
-  BackupManager,
-  GlobalPatternsIndexSchema,
-  safeParseAndValidate
-} from "./chunk-EFWVF6TI.js";
-import {
-  atomicWriteJSON
-} from "./chunk-43X6JBEM.js";
-
-// src/memory/global-memory.ts
-import { mkdir, writeFile, readFile, readdir } from "fs/promises";
-import { createHash } from "crypto";
-import { existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-var GLOBAL_TRIE_DIR = join(homedir(), ".trie");
-var GLOBAL_MEMORY_DIR = join(GLOBAL_TRIE_DIR, "memory");
-async function recordToGlobalMemory(issues, projectName, projectPath) {
-  await mkdir(GLOBAL_MEMORY_DIR, { recursive: true });
-  await mkdir(join(GLOBAL_MEMORY_DIR, "projects"), { recursive: true });
-  const patterns = await loadGlobalPatterns();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const issue of issues) {
-    const patternId = extractPatternId(issue);
-    const existing = patterns.find((p) => p.id === patternId);
-    if (existing) {
-      existing.occurrences++;
-      existing.lastSeen = now;
-      if (!existing.projects.includes(projectName)) {
-        existing.projects.push(projectName);
-      }
-    } else {
-      patterns.push({
-        id: patternId,
-        pattern: issue.issue.slice(0, 200),
-        description: issue.fix.slice(0, 200),
-        severity: issue.severity,
-        agent: issue.agent,
-        occurrences: 1,
-        projects: [projectName],
-        firstSeen: now,
-        lastSeen: now
-      });
-    }
-  }
-  await saveGlobalPatterns(patterns);
-  const summaryPath = join(GLOBAL_MEMORY_DIR, "projects", `${sanitizeName(projectName)}.json`);
-  const summary = {
-    name: projectName,
-    path: projectPath,
-    lastScan: now,
-    totalIssues: issues.length,
-    patterns: [...new Set(issues.map((i) => extractPatternId(i)))]
-  };
-  await atomicWriteJSON(summaryPath, summary);
-}
-async function findCrossProjectPatterns(minOccurrences = 2) {
-  const patterns = await loadGlobalPatterns();
-  return patterns.filter((p) => p.projects.length >= minOccurrences).sort((a, b) => b.occurrences - a.occurrences);
-}
-async function listTrackedProjects() {
-  const projectsDir = join(GLOBAL_MEMORY_DIR, "projects");
-  try {
-    if (!existsSync(projectsDir)) return [];
-    const files = await readdir(projectsDir);
-    const summaries = [];
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-      try {
-        const content = await readFile(join(projectsDir, file), "utf-8");
-        summaries.push(JSON.parse(content));
-      } catch {
-      }
-    }
-    return summaries.sort(
-      (a, b) => new Date(b.lastScan).getTime() - new Date(a.lastScan).getTime()
-    );
-  } catch {
-    return [];
-  }
-}
-async function getGlobalMemoryStats() {
-  const patterns = await loadGlobalPatterns();
-  const projects = await listTrackedProjects();
-  const MAX_PATTERNS = 500;
-  const patternsByAgent = {};
-  for (const pattern of patterns) {
-    patternsByAgent[pattern.agent] = (patternsByAgent[pattern.agent] || 0) + 1;
-  }
-  const totalOccurrences = patterns.reduce((sum, p) => sum + p.occurrences, 0);
-  const avgOccurrences = patterns.length > 0 ? totalOccurrences / patterns.length : 0;
-  return {
-    totalPatterns: patterns.length,
-    crossProjectPatterns: patterns.filter((p) => p.projects.length >= 2).length,
-    trackedProjects: projects.length,
-    totalOccurrences,
-    fixedPatterns: patterns.filter((p) => p.fixApplied).length,
-    patternsByAgent,
-    capacityInfo: {
-      current: patterns.length,
-      max: MAX_PATTERNS,
-      percentFull: Math.round(patterns.length / MAX_PATTERNS * 100),
-      isAtCap: patterns.length >= MAX_PATTERNS
-    },
-    deduplicationStats: {
-      uniquePatterns: patterns.length,
-      averageOccurrences: Math.round(avgOccurrences * 10) / 10
-    }
-  };
-}
-async function updateGlobalMemoryMd() {
-  const patterns = await loadGlobalPatterns();
-  const crossProject = patterns.filter((p) => p.projects.length >= 2);
-  const projects = await listTrackedProjects();
-  const lines = [
-    "# Global Trie Memory",
-    "",
-    "> Auto-generated file tracking patterns across all your projects.",
-    `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "## Summary",
-    "",
-    `- **Projects tracked:** ${projects.length}`,
-    `- **Total patterns:** ${patterns.length}`,
-    `- **Cross-project patterns:** ${crossProject.length}`,
-    "",
-    "## Cross-Project Patterns",
-    "",
-    "These issues appear in multiple projects:",
-    ""
-  ];
-  for (const p of crossProject.slice(0, 20)) {
-    lines.push(
-      `### ${p.pattern.slice(0, 60)}${p.pattern.length > 60 ? "..." : ""}`,
-      "",
-      `- **Severity:** ${p.severity}`,
-      `- **Agent:** ${p.agent}`,
-      `- **Occurrences:** ${p.occurrences} across ${p.projects.length} projects`,
-      `- **Projects:** ${p.projects.slice(0, 5).join(", ")}${p.projects.length > 5 ? "..." : ""}`
-    );
-    if (p.fixApplied) {
-      lines.push(`- **Fixed in:** ${p.fixApplied.project} on ${p.fixApplied.timestamp.split("T")[0]}`);
-    } else {
-      lines.push("- **Status:** Not fixed");
-    }
-    lines.push("");
-  }
-  lines.push(
-    "## Tracked Projects",
-    "",
-    "| Project | Last Scan | Issues |",
-    "|---------|-----------|--------|"
-  );
-  for (const p of projects.slice(0, 20)) {
-    lines.push(`| ${p.name} | ${p.lastScan.split("T")[0]} | ${p.totalIssues} |`);
-  }
-  lines.push("", "---", "", "*This file is auto-generated by Trie. Do not edit manually.*");
-  await mkdir(GLOBAL_MEMORY_DIR, { recursive: true });
-  await writeFile(join(GLOBAL_MEMORY_DIR, "GLOBAL_MEMORY.md"), lines.join("\n"));
-}
-async function searchGlobalPatterns(query, options = {}) {
-  const patterns = await loadGlobalPatterns();
-  const limit = options.limit || 10;
-  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
-  const scored = patterns.filter((p) => {
-    if (options.severity && !options.severity.includes(p.severity)) return false;
-    if (options.agent && p.agent !== options.agent) return false;
-    return true;
-  }).map((p) => {
-    const text = `${p.pattern} ${p.description} ${p.agent}`.toLowerCase();
-    let score = 0;
-    for (const term of queryTerms) {
-      if (text.includes(term)) score++;
-    }
-    return { pattern: p, score };
-  }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
-  return scored.map((s) => s.pattern);
-}
-async function loadGlobalPatterns() {
-  const patternsPath = join(GLOBAL_MEMORY_DIR, "global-patterns.json");
-  try {
-    if (existsSync(patternsPath)) {
-      const content = await readFile(patternsPath, "utf-8");
-      const result = safeParseAndValidate(content, GlobalPatternsIndexSchema);
-      if (result.success) {
-        return result.data;
-      }
-      const backupManager = new BackupManager(patternsPath);
-      if (await backupManager.recoverFromBackup()) {
-        const recovered = await readFile(patternsPath, "utf-8");
-        const recoveredResult = safeParseAndValidate(recovered, GlobalPatternsIndexSchema);
-        if (recoveredResult.success) {
-          return recoveredResult.data;
-        }
-      }
-    }
-  } catch {
-  }
-  return [];
-}
-async function saveGlobalPatterns(patterns) {
-  await mkdir(GLOBAL_MEMORY_DIR, { recursive: true });
-  const patternsPath = join(GLOBAL_MEMORY_DIR, "global-patterns.json");
-  const patternMap = /* @__PURE__ */ new Map();
-  for (const pattern of patterns) {
-    const existing = patternMap.get(pattern.id);
-    if (existing) {
-      existing.occurrences += pattern.occurrences;
-      for (const proj of pattern.projects) {
-        if (!existing.projects.includes(proj)) {
-          existing.projects.push(proj);
-        }
-      }
-      existing.lastSeen = pattern.lastSeen > existing.lastSeen ? pattern.lastSeen : existing.lastSeen;
-    } else {
-      patternMap.set(pattern.id, pattern);
-    }
-  }
-  const deduplicated = Array.from(patternMap.values());
-  const pruned = intelligentPruneGlobalPatterns(deduplicated, 500);
-  const backupManager = new BackupManager(patternsPath);
-  await backupManager.createBackup();
-  await atomicWriteJSON(patternsPath, pruned);
-}
-function intelligentPruneGlobalPatterns(patterns, targetCount) {
-  if (patterns.length <= targetCount) {
-    return patterns;
-  }
-  const severityWeight = {
-    critical: 100,
-    high: 50,
-    moderate: 20,
-    low: 10,
-    info: 5
-  };
-  const scored = patterns.map((pattern) => {
-    const ageInDays = (Date.now() - new Date(pattern.lastSeen).getTime()) / (1e3 * 60 * 60 * 24);
-    const recencyScore = Math.max(0, 100 - ageInDays * 2);
-    const severityScore = severityWeight[pattern.severity] || 10;
-    const crossProjectBonus = (pattern.projects.length - 1) * 30;
-    const fixedBonus = pattern.fixApplied ? 20 : 0;
-    const occurrenceScore = Math.min(pattern.occurrences * 2, 100);
-    return {
-      pattern,
-      score: recencyScore + severityScore + crossProjectBonus + fixedBonus + occurrenceScore
-    };
-  });
-  return scored.sort((a, b) => b.score - a.score).slice(0, targetCount).map((s) => s.pattern);
-}
-function extractPatternId(issue) {
-  const normalized = issue.issue.toLowerCase().replace(/`[^`]+`/g, "CODE").replace(/\b\d+\b/g, "N").replace(/['"]/g, "").slice(0, 100);
-  const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 12);
-  return `${issue.agent}-${issue.severity}-${hash}`;
-}
-function sanitizeName(name) {
-  return name.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
-}
-
-// src/agent/gotcha-predictor.ts
-import fs from "fs";
-import path from "path";
-var GotchaPredictor = class {
-  projectPath;
-  graph;
-  constructor(projectPath, graph) {
-    this.projectPath = projectPath;
-    this.graph = graph;
-  }
-  async predictGotchas(changedFiles) {
-    const gotchas = [];
-    const tickets = (await this.graph.listNodes()).filter((n) => n.type === "linear-ticket");
-    for (const file of changedFiles) {
-      const fileGotchas = await this.predictForFile(file, tickets);
-      gotchas.push(...fileGotchas);
-    }
-    return gotchas;
-  }
-  async predictForFile(filePath, tickets) {
-    const gotchas = [];
-    const fullPath = path.resolve(this.projectPath, filePath);
-    if (!fs.existsSync(fullPath)) return [];
-    const content = fs.readFileSync(fullPath, "utf-8");
-    const storage = getStorage(this.projectPath);
-    await storage.initialize();
-    const tags = this.extractTagsFromFile(filePath, []);
-    const relevantGovernance = await storage.queryGovernance({
-      tags,
-      limit: 10
-    });
-    const activeBlockers = await storage.queryBlockers({
-      tags,
-      limit: 5
-    });
-    for (const gov of relevantGovernance) {
-      if (gov.files.some((f) => f.includes(filePath) || filePath.includes(f))) {
-        gotchas.push({
-          id: `gotcha-gov-${gov.id}`,
-          message: `Governance: ${gov.decision}`,
-          confidence: 0.85,
-          riskLevel: "medium",
-          precedentId: gov.id,
-          recommendation: gov.reasoning || "Review this governance before making changes",
-          evidence: {
-            pastIncidents: [],
-            matchingPatterns: gov.tags,
-            relatedTickets: []
-          }
-        });
-      }
-    }
-    for (const blocker of activeBlockers) {
-      gotchas.push({
-        id: `gotcha-blocker-${blocker.id}`,
-        message: `\u26A0\uFE0F Active Blocker: ${blocker.blocker}`,
-        confidence: 0.95,
-        riskLevel: blocker.impact === "critical" ? "critical" : blocker.impact === "high" ? "high" : "medium",
-        recommendation: `This area is currently blocked. Consider resolving this before making changes.`,
-        evidence: {
-          pastIncidents: [],
-          matchingPatterns: blocker.tags,
-          relatedTickets: []
-        }
-      });
-    }
-    const aiGotchas = await this.analyzeCodeWithAI(filePath, content, relevantGovernance, activeBlockers);
-    gotchas.push(...aiGotchas);
-    for (const ticket of tickets) {
-      const ticketData = ticket.data;
-      const historicalPrecedents = await this.findHistoricalPrecedents(filePath, ticketData);
-      if (historicalPrecedents) {
-        gotchas.push(historicalPrecedents);
-      }
-    }
-    return gotchas;
-  }
-  /**
-   * Use AI to analyze code for potential issues
-   */
-  async analyzeCodeWithAI(filePath, content, governance, blockers) {
-    const client = tryGetClient();
-    if (!client) return [];
-    try {
-      const governanceContext = governance.length > 0 ? `
-
-Relevant Governance:
-${governance.map((g) => `- ${g.decision}: ${g.reasoning || "No reasoning provided"}`).join("\n")}` : "";
-      const blockerContext = blockers.length > 0 ? `
-
-Active Blockers:
-${blockers.map((b) => `- [${b.impact}] ${b.blocker}`).join("\n")}` : "";
-      const systemPrompt = `You are a senior code reviewer analyzing code for potential issues before changes are shipped.
-
-Given a file and its context (governance decisions and blockers), identify:
-1. Potential bugs or security issues
-2. Violations of governance decisions
-3. Conflicts with active blockers
-4. Anti-patterns or code smells
-
-Return your analysis as a JSON array of issues, each with:
-{
-  "message": "Brief description of the issue",
-  "confidence": 0.0-1.0,
-  "riskLevel": "low" | "medium" | "high" | "critical",
-  "recommendation": "Specific recommendation",
-  "lineNumber": number (if applicable)
-}
-
-IMPORTANT: Only return JSON, no other text. If no issues found, return [].`;
-      const userPrompt = `File: ${filePath}${governanceContext}${blockerContext}
-
-Code:
-\`\`\`
-${content.slice(0, 5e3)}
-\`\`\`
-
-Analyze this code and return a JSON array of potential issues.`;
-      const response = await client.messages.create({
-        model: "claude-sonnet-4-20250514",
-        max_tokens: 4096,
-        temperature: 0.2,
-        system: systemPrompt,
-        messages: [{ role: "user", content: userPrompt }]
-      });
-      const textContent = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
-      const jsonMatch = textContent.match(/\[[\s\S]*\]/);
-      if (!jsonMatch) return [];
-      const issues = JSON.parse(jsonMatch[0]);
-      return issues.map((issue, idx) => ({
-        id: `gotcha-ai-${Date.now()}-${idx}`,
-        message: issue.message || "AI-detected issue",
-        confidence: issue.confidence || 0.7,
-        riskLevel: issue.riskLevel || "medium",
-        recommendation: issue.recommendation || "Review this code carefully",
-        evidence: {
-          pastIncidents: [],
-          matchingPatterns: ["ai-analysis"],
-          relatedTickets: []
-        }
-      }));
-    } catch (error) {
-      return [];
-    }
-  }
-  /**
-   * Extract tags from file path for storage queries
-   */
-  extractTagsFromFile(filePath, _signatures) {
-    const tags = /* @__PURE__ */ new Set();
-    const normalized = filePath.toLowerCase();
-    if (normalized.includes("/auth/")) tags.add("auth");
-    if (normalized.includes("/payment/")) tags.add("payments");
-    if (normalized.includes("/api/")) tags.add("api");
-    if (normalized.includes("/frontend/") || normalized.includes("/ui/")) tags.add("ui");
-    if (normalized.includes("/backend/")) tags.add("backend");
-    if (normalized.includes("/database/") || normalized.includes("/models/")) tags.add("database");
-    return Array.from(tags);
-  }
-  async findHistoricalPrecedents(filePath, ticket) {
-    const similarIssues = await searchIssues(ticket.description, {
-      workDir: this.projectPath,
-      limit: 3
-    });
-    const relevantIssues = similarIssues.filter((r) => r.issue.file === filePath || r.issue.file.includes(path.basename(filePath)));
-    const [firstMatch] = relevantIssues;
-    if (firstMatch) {
-      const issue = firstMatch.issue;
-      return {
-        id: `gotcha-precedent-${ticket.ticketId}-${Date.now()}`,
-        message: `A similar task in the past caused an issue: "${issue.issue}"`,
-        confidence: 0.9,
-        riskLevel: "critical",
-        precedentId: issue.id,
-        recommendation: `Last time we worked on something similar here, we had to fix: "${issue.fix}". Check this first.`,
-        evidence: {
-          pastIncidents: [issue.id],
-          matchingPatterns: [],
-          relatedTickets: [ticket.ticketId]
-        }
-      };
-    }
-    return null;
-  }
-  async synthesizeGotchaExplanation(gotcha) {
-    const client = tryGetClient();
-    if (!client) return gotcha.message;
-    const prompt = `
-      You are a JIT Defect Predictor. You found a potential "gotcha" for a developer.
-      
-      Ticket context: ${gotcha.evidence.relatedTickets.join(", ")}
-      Tags: ${gotcha.evidence.matchingPatterns.join(", ")}
-      Past incidents: ${gotcha.evidence.pastIncidents.join(", ")}
-      
-      Raw message: ${gotcha.message}
-      Recommendation: ${gotcha.recommendation}
-      
-      Explain this gotcha in a concise, human-friendly way (max 2 sentences). 
-      Make it sound like a senior dev giving a helpful nudge.
-    `;
-    try {
-      const response = await client.messages.create({
-        model: "claude-3-5-sonnet-20240620",
-        max_tokens: 100,
-        messages: [{ role: "user", content: prompt }]
-      });
-      const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
-      return text.trim() || gotcha.message;
-    } catch {
-      return gotcha.message;
-    }
-  }
-};
-
-// src/integrations/slack.ts
-var SlackIntegration = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Send scan completion notification
-   */
-  async sendScanNotification(_issues, priorityReport, repositoryName, branch = "main") {
-    const { urgent, high, medium, low } = priorityReport;
-    const statusEmoji = urgent.length > 0 ? "[URGENT]" : high.length > 0 ? "[HIGH]" : "[OK]";
-    const message = {
-      blocks: [
-        {
-          type: "section",
-          text: {
-            type: "mrkdwn",
-            text: `${statusEmoji} *Trie Security Scan Complete*
-*Repository:* ${repositoryName} (${branch})`
-          }
-        },
-        {
-          type: "section",
-          fields: [
-            {
-              type: "mrkdwn",
-              text: `*Urgent:* ${urgent.length}`
-            },
-            {
-              type: "mrkdwn",
-              text: `*High:* ${high.length}`
-            },
-            {
-              type: "mrkdwn",
-              text: `*Medium:* ${medium.length}`
-            },
-            {
-              type: "mrkdwn",
-              text: `*\u{1F539} Low:* ${low.length}`
-            }
-          ]
-        }
-      ],
-      attachments: []
-    };
-    if (urgent.length > 0) {
-      const urgentDetails = urgent.slice(0, 5).map(
-        (group) => `\u2022 ${group.description} (${group.count} instances)`
-      ).join("\n");
-      message.attachments.push({
-        color: "danger",
-        title: "Urgent Issues - Immediate Action Required",
-        text: urgentDetails,
-        footer: urgent.length > 5 ? `... and ${urgent.length - 5} more urgent issues` : void 0
-      });
-    }
-    if (high.length > 0) {
-      const highDetails = high.slice(0, 3).map(
-        (group) => `\u2022 ${group.description} (${group.count} instances)`
-      ).join("\n");
-      message.attachments.push({
-        color: "warning",
-        title: "High Priority Issues",
-        text: highDetails,
-        footer: high.length > 3 ? `... and ${high.length - 3} more high priority issues` : void 0
-      });
-    }
-    if (priorityReport.recommendations.length > 0) {
-      message.attachments.push({
-        color: "good",
-        title: "Recommendations",
-        text: priorityReport.recommendations.slice(0, 3).join("\n")
-      });
-    }
-    await this.sendMessage(message);
-  }
-  /**
-   * Send critical issue alert
-   */
-  async sendCriticalAlert(issues, repositoryName) {
-    const message = {
-      text: `CRITICAL SECURITY ALERT: ${repositoryName}`,
-      blocks: [
-        {
-          type: "section",
-          text: {
-            type: "mrkdwn",
-            text: `*CRITICAL SECURITY ALERT*
-*Repository:* ${repositoryName}
-*Critical Issues:* ${issues.length}`
-          }
-        }
-      ],
-      attachments: issues.slice(0, 5).map((issue) => ({
-        color: "danger",
-        title: `${issue.file}:${issue.line || "?"}`,
-        text: issue.issue.slice(0, 200),
-        fields: [
-          {
-            title: "Fix",
-            value: issue.fix.slice(0, 100),
-            short: false
-          }
-        ],
-        footer: `Agent: ${issue.agent}`,
-        ts: Math.floor(Date.now() / 1e3)
-      }))
-    };
-    if (issues.length > 5) {
-      message.attachments.push({
-        color: "danger",
-        text: `... and ${issues.length - 5} more critical issues. View full report for details.`
-      });
-    }
-    await this.sendMessage(message);
-  }
-  /**
-   * Send team notification
-   */
-  async sendTeamNotification(notification) {
-    const emoji = this.getNotificationEmoji(notification.type);
-    const message = {
-      blocks: [
-        {
-          type: "section",
-          text: {
-            type: "mrkdwn",
-            text: `${emoji} *${notification.title}*
-${notification.message}`
-          }
-        }
-      ]
-    };
-    if (notification.type === "assignment" && notification.data) {
-      const { assignment, issue } = notification.data;
-      message.attachments = [{
-        color: this.getAssignmentColor(assignment.priority),
-        fields: [
-          {
-            title: "Priority",
-            value: assignment.priority.toUpperCase(),
-            short: true
-          },
-          {
-            title: "Due Date",
-            value: assignment.dueDate ? new Date(assignment.dueDate).toLocaleDateString() : "Not set",
-            short: true
-          },
-          {
-            title: "File",
-            value: issue.file,
-            short: false
-          }
-        ]
-      }];
-    }
-    await this.sendMessage(message);
-  }
-  /**
-   * Send daily/weekly team summary
-   */
-  async sendTeamSummary(period, stats) {
-    const emoji = period === "daily" ? "[DAILY]" : "[WEEKLY]";
-    const title = `${emoji} ${period.charAt(0).toUpperCase() + period.slice(1)} Security Summary`;
-    const message = {
-      blocks: [
-        {
-          type: "section",
-          text: {
-            type: "mrkdwn",
-            text: `*${title}*`
-          }
-        },
-        {
-          type: "section",
-          fields: [
-            {
-              type: "mrkdwn",
-              text: `*New Issues:* ${stats.newIssues}`
-            },
-            {
-              type: "mrkdwn",
-              text: `*\u2705 Resolved:* ${stats.resolvedIssues}`
-            },
-            {
-              type: "mrkdwn",
-              text: `*Overdue:* ${stats.overdueIssues}`
-            },
-            {
-              type: "mrkdwn",
-              text: `*Net Change:* ${stats.resolvedIssues - stats.newIssues > 0 ? "+" : ""}${stats.resolvedIssues - stats.newIssues}`
-            }
-          ]
-        }
-      ],
-      attachments: []
-    };
-    if (stats.topCategories.length > 0) {
-      const categoriesText = stats.topCategories.slice(0, 5).map((cat) => `\u2022 ${cat.category}: ${cat.count}`).join("\n");
-      message.attachments.push({
-        color: "good",
-        title: "Top Issue Categories",
-        text: categoriesText
-      });
-    }
-    if (stats.topContributors.length > 0) {
-      const contributorsText = stats.topContributors.slice(0, 5).map((contrib) => `\u2022 ${contrib.name}: ${contrib.resolved} resolved`).join("\n");
-      message.attachments.push({
-        color: "good",
-        title: "Top Contributors",
-        text: contributorsText
-      });
-    }
-    await this.sendMessage(message);
-  }
-  /**
-   * Send bulk fix notification
-   */
-  async sendBulkFixNotification(fixedGroups, totalFixed, repositoryName) {
-    const message = {
-      blocks: [
-        {
-          type: "section",
-          text: {
-            type: "mrkdwn",
-            text: `*Bulk Fix Applied*
-*Repository:* ${repositoryName}
-*Issues Fixed:* ${totalFixed}`
-          }
-        }
-      ],
-      attachments: [{
-        color: "good",
-        title: "\u{1F527} Fixed Issue Groups",
-        text: fixedGroups.map(
-          (group) => `\u2022 ${group.description} (${group.count} instances)`
-        ).join("\n")
-      }]
-    };
-    await this.sendMessage(message);
-  }
-  /**
-   * Send escalation notification
-   */
-  async sendEscalationNotification(overdueAssignments) {
-    const message = {
-      text: "OVERDUE ISSUE ESCALATION",
-      blocks: [
-        {
-          type: "section",
-          text: {
-            type: "mrkdwn",
-            text: `*Overdue Issue Escalation*
-${overdueAssignments.length} issues are overdue and require attention.`
-          }
-        }
-      ],
-      attachments: overdueAssignments.map((assignment) => ({
-        color: "warning",
-        title: `Issue ${assignment.issueId}`,
-        fields: [
-          {
-            title: "Assignee",
-            value: assignment.assignee,
-            short: true
-          },
-          {
-            title: "Days Overdue",
-            value: assignment.daysOverdue.toString(),
-            short: true
-          },
-          {
-            title: "Priority",
-            value: assignment.priority.toUpperCase(),
-            short: true
-          }
-        ]
-      }))
-    };
-    await this.sendMessage(message);
-  }
-  /**
-   * Send message to Slack
-   */
-  async sendMessage(message) {
-    const payload = {
-      ...message,
-      channel: this.config.channel || message.channel,
-      username: this.config.username || "Trie Security Bot",
-      icon_emoji: this.config.iconEmoji || ":shield:"
-    };
-    try {
-      const response = await fetch(this.config.webhookUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(payload)
-      });
-      if (!response.ok) {
-        throw new Error(`Slack API error: ${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      console.error("Failed to send Slack notification:", error);
-      throw error;
-    }
-  }
-  /**
-   * Get emoji for notification type
-   */
-  getNotificationEmoji(type) {
-    const emojis = {
-      assignment: "[ASSIGN]",
-      escalation: "[ESCALATE]",
-      completion: "[DONE]",
-      reminder: "[REMIND]"
-    };
-    return emojis[type] ?? "[NOTIFY]";
-  }
-  /**
-   * Get color for assignment priority
-   */
-  getAssignmentColor(priority) {
-    const colors = {
-      urgent: "danger",
-      high: "warning",
-      medium: "good",
-      low: "#36a64f"
-    };
-    return colors[priority] ?? "good";
-  }
-  /**
-   * Test Slack connection
-   */
-  async testConnection() {
-    try {
-      await this.sendMessage({
-        text: "Trie Slack Integration Test",
-        blocks: [{
-          type: "section",
-          text: {
-            type: "mrkdwn",
-            text: "*Trie Slack Integration Test*\nIf you see this message, the integration is working correctly!"
-          }
-        }]
-      });
-      return true;
-    } catch (error) {
-      console.error("Slack connection test failed:", error);
-      return false;
-    }
-  }
-};
-
-export {
-  recordToGlobalMemory,
-  findCrossProjectPatterns,
-  listTrackedProjects,
-  getGlobalMemoryStats,
-  updateGlobalMemoryMd,
-  searchGlobalPatterns,
-  SlackIntegration,
-  GotchaPredictor
-};
-//# sourceMappingURL=chunk-AHD2CBQ7.js.map