@triedotdev/mcp 1.0.93 → 1.0.97

package/dist/chunk-CUXXRM3T.js

@@ -1,2124 +0,0 @@
-import {
-  CacheManager
-} from "./chunk-HFQ5ORON.js";
-import {
-  CustomSkill,
-  getSkillRegistry,
-  loadContextState
-} from "./chunk-BG2BHWCC.js";
-import {
-  getGlobalMemoryStats
-} from "./chunk-LT7MKIXU.js";
-import {
-  getHistoricalInsights,
-  getMemoryStats,
-  getRecentIssues,
-  searchIssues
-} from "./chunk-LP4MVJDW.js";
-import {
-  getTrieDirectory,
-  getWorkingDirectory
-} from "./chunk-RDOJCRKJ.js";
-import {
-  isInteractiveMode
-} from "./chunk-D25EIBPO.js";
-import {
-  __require
-} from "./chunk-DGUM43GV.js";
-
-// src/utils/trie-init.ts
-import { existsSync } from "fs";
-import { join } from "path";
-var INIT_MARKERS = [
-  "PROJECT.md",
-  "RULES.md",
-  "TEAM.md",
-  "BOOTSTRAP.md",
-  "AGENTS.md",
-  "config.json"
-];
-function isTrieInitialized(workDir) {
-  const dir = workDir || getWorkingDirectory(void 0, true);
-  const trieDir = getTrieDirectory(dir);
-  return INIT_MARKERS.some((marker) => existsSync(join(trieDir, marker)));
-}
-
-// src/config/loader.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, dirname } from "path";
-
-// src/config/validation.ts
-import { z } from "zod";
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { resolve, join as join2 } from "path";
-var API_KEY_PATTERNS = {
-  anthropic: /^sk-ant-api\d{2}-[\w-]{95}$/,
-  openai: /^sk-[\w]{48}$/,
-  github: /^ghp_[\w]{36}$/,
-  vercel: /^[\w]{24}$/,
-  linear: /^lin_api_[\w]{40,60}$/
-};
-var ApiKeysSchema = z.object({
-  anthropic: z.string().regex(API_KEY_PATTERNS.anthropic, "Invalid Anthropic API key format").optional(),
-  openai: z.string().regex(API_KEY_PATTERNS.openai, "Invalid OpenAI API key format").optional(),
-  github: z.string().regex(API_KEY_PATTERNS.github, "Invalid GitHub token format").optional(),
-  vercel: z.string().regex(API_KEY_PATTERNS.vercel, "Invalid Vercel token format").optional(),
-  linear: z.string().optional()
-  // Linear keys can vary, so we'll be flexible but allow storage
-});
-var AgentConfigSchema = z.object({
-  enabled: z.array(z.string()).optional().default([]),
-  disabled: z.array(z.string()).optional().default([]),
-  parallel: z.boolean().optional().default(true),
-  maxConcurrency: z.number().int().min(1).max(20).optional().default(4),
-  timeout: z.number().int().min(1e3).max(3e5).optional().default(12e4),
-  // 2 minutes
-  cache: z.boolean().optional().default(true)
-});
-var ComplianceSchema = z.object({
-  standards: z.array(z.enum(["SOC2", "GDPR", "HIPAA", "CCPA", "PCI-DSS"])).optional().default(["SOC2"]),
-  enforceCompliance: z.boolean().optional().default(false),
-  reportFormat: z.enum(["json", "sarif", "csv", "html"]).optional().default("json")
-});
-var OutputSchema = z.object({
-  format: z.enum(["console", "json", "sarif", "junit"]).optional().default("console"),
-  level: z.enum(["critical", "serious", "moderate", "low", "all"]).optional().default("all"),
-  interactive: z.boolean().optional().default(false),
-  streaming: z.boolean().optional().default(true),
-  colors: z.boolean().optional().default(true)
-});
-var PathsSchema = z.object({
-  include: z.array(z.string()).optional().default([]),
-  exclude: z.array(z.string()).optional().default(["node_modules", "dist", "build", ".git"]),
-  configDir: z.string().optional().default(".trie"),
-  outputDir: z.string().optional().default("trie-reports")
-});
-var IntegrationsSchema = z.object({
-  github: z.object({
-    enabled: z.boolean().optional().default(false),
-    token: z.string().optional(),
-    webhook: z.string().url().optional()
-  }).optional(),
-  slack: z.object({
-    enabled: z.boolean().optional().default(false),
-    webhook: z.string().url().optional(),
-    channel: z.string().optional()
-  }).optional(),
-  jira: z.object({
-    enabled: z.boolean().optional().default(false),
-    url: z.string().url().optional(),
-    token: z.string().optional(),
-    project: z.string().optional()
-  }).optional()
-});
-var UserSchema = z.object({
-  name: z.string().min(1).optional(),
-  email: z.string().email().optional(),
-  role: z.enum([
-    "developer",
-    "designer",
-    "qa",
-    "devops",
-    "security",
-    "architect",
-    "manager",
-    "contributor"
-  ]).optional().default("developer"),
-  github: z.string().optional(),
-  // GitHub username
-  url: z.string().url().optional()
-  // Personal/portfolio URL
-});
-var TrieConfigSchema = z.object({
-  version: z.string().optional().default("1.0.0"),
-  apiKeys: ApiKeysSchema.optional(),
-  agents: AgentConfigSchema.optional(),
-  compliance: ComplianceSchema.optional(),
-  output: OutputSchema.optional(),
-  paths: PathsSchema.optional(),
-  integrations: IntegrationsSchema.optional(),
-  user: UserSchema.optional()
-  // User identity for attribution
-});
-var ConfigValidator = class {
-  /**
-   * Validate configuration object
-   */
-  validateConfig(config) {
-    try {
-      const validated = TrieConfigSchema.parse(config);
-      const businessErrors = this.validateBusinessLogic(validated);
-      if (businessErrors.length > 0) {
-        return { success: false, errors: businessErrors };
-      }
-      return { success: true, data: validated };
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        const errors = error.errors.map(
-          (err) => `${err.path.join(".")}: ${err.message}`
-        );
-        return { success: false, errors };
-      }
-      return {
-        success: false,
-        errors: [`Configuration validation failed: ${error instanceof Error ? error.message : "Unknown error"}`]
-      };
-    }
-  }
-  /**
-   * Validate environment variables for API keys
-   */
-  validateEnvironment() {
-    const warnings = [];
-    const errors = [];
-    const exposedPatterns = [
-      "NEXT_PUBLIC_ANTHROPIC",
-      "REACT_APP_ANTHROPIC",
-      "VITE_ANTHROPIC",
-      "PUBLIC_ANTHROPIC"
-    ];
-    for (const pattern of exposedPatterns) {
-      const envVars = Object.keys(process.env).filter((key) => key.includes(pattern));
-      for (const envVar of envVars) {
-        errors.push(`[!] Security risk: API key in client-side environment variable: ${envVar}`);
-      }
-    }
-    let anthropicKey = process.env.ANTHROPIC_API_KEY;
-    if (!anthropicKey) {
-      try {
-        const configPath = join2(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-        if (existsSync2(configPath)) {
-          const config = JSON.parse(readFileSync(configPath, "utf-8"));
-          anthropicKey = config.apiKeys?.anthropic;
-        }
-      } catch {
-      }
-    }
-    if (anthropicKey && !API_KEY_PATTERNS.anthropic.test(anthropicKey)) {
-      errors.push("ANTHROPIC_API_KEY does not match expected format");
-    }
-    if (!anthropicKey) {
-      warnings.push("ANTHROPIC_API_KEY not set - AI features will be disabled. Set in environment, .trie/config.json, or .env file");
-    }
-    if (!process.env.GITHUB_TOKEN && process.env.CI) {
-      warnings.push("GITHUB_TOKEN not set - GitHub integration disabled");
-    }
-    return {
-      valid: errors.length === 0,
-      warnings,
-      errors
-    };
-  }
-  /**
-   * Validate file paths in configuration
-   */
-  validatePaths(paths) {
-    const errors = [];
-    if (paths?.include) {
-      for (const path of paths.include) {
-        const resolvedPath = resolve(path);
-        if (!existsSync2(resolvedPath)) {
-          errors.push(`Include path does not exist: ${path}`);
-        }
-      }
-    }
-    if (paths?.configDir) {
-      const configPath = resolve(paths.configDir);
-      if (!existsSync2(configPath)) {
-        try {
-          __require("fs").mkdirSync(configPath, { recursive: true });
-        } catch {
-          errors.push(`Cannot create config directory: ${paths.configDir}`);
-        }
-      }
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  /**
-   * Validate integration configurations
-   */
-  validateIntegrations(integrations) {
-    const errors = [];
-    if (integrations?.github?.enabled) {
-      if (!integrations.github.token) {
-        errors.push("GitHub integration enabled but no token provided");
-      }
-    }
-    if (integrations?.slack?.enabled) {
-      if (!integrations.slack.webhook) {
-        errors.push("Slack integration enabled but no webhook URL provided");
-      }
-    }
-    if (integrations?.jira?.enabled) {
-      if (!integrations.jira.url || !integrations.jira.token || !integrations.jira.project) {
-        errors.push("JIRA integration enabled but missing required fields (url, token, project)");
-      }
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  /**
-   * Business logic validation
-   */
-  validateBusinessLogic(config) {
-    const errors = [];
-    if (config.agents?.enabled && config.agents?.disabled) {
-      const overlap = config.agents.enabled.filter(
-        (agent) => config.agents?.disabled?.includes(agent)
-      );
-      if (overlap.length > 0) {
-        errors.push(`Agents cannot be both enabled and disabled: ${overlap.join(", ")}`);
-      }
-    }
-    if (config.agents?.maxConcurrency && config.agents.maxConcurrency > 10) {
-      errors.push("maxConcurrency should not exceed 10 for optimal performance");
-    }
-    if (config.compliance?.standards) {
-      const invalidStandards = config.compliance.standards.filter(
-        (standard) => !["SOC2", "GDPR", "HIPAA", "CCPA", "PCI-DSS"].includes(standard)
-      );
-      if (invalidStandards.length > 0) {
-        errors.push(`Invalid compliance standards: ${invalidStandards.join(", ")}`);
-      }
-    }
-    if (config.paths) {
-      const pathValidation = this.validatePaths(config.paths);
-      errors.push(...pathValidation.errors);
-    }
-    if (config.integrations) {
-      const integrationValidation = this.validateIntegrations(config.integrations);
-      errors.push(...integrationValidation.errors);
-    }
-    return errors;
-  }
-  /**
-   * Generate configuration template
-   */
-  generateTemplate() {
-    return {
-      version: "1.0.0",
-      agents: {
-        enabled: ["security", "bugs", "types"],
-        disabled: [],
-        parallel: true,
-        maxConcurrency: 4,
-        timeout: 12e4,
-        cache: true
-      },
-      compliance: {
-        standards: ["SOC2"],
-        enforceCompliance: false,
-        reportFormat: "json"
-      },
-      output: {
-        format: "console",
-        level: "all",
-        interactive: false,
-        streaming: true,
-        colors: true
-      },
-      paths: {
-        include: [],
-        exclude: ["node_modules", "dist", "build", ".git"],
-        configDir: ".trie",
-        outputDir: "trie-reports"
-      }
-    };
-  }
-  /**
-   * Validate and provide suggestions for improvement
-   */
-  analyze(config) {
-    const suggestions = [];
-    const securityIssues = [];
-    const optimizations = [];
-    let score = 100;
-    let hasApiKey = Boolean(config.apiKeys?.anthropic || process.env.ANTHROPIC_API_KEY);
-    if (!hasApiKey) {
-      try {
-        const workDir = getWorkingDirectory(void 0, true);
-        const envFiles = [".env", ".env.local", ".env.production"];
-        for (const envFile of envFiles) {
-          const envPath = join2(workDir, envFile);
-          if (existsSync2(envPath)) {
-            const envContent = readFileSync(envPath, "utf-8");
-            if (envContent.includes("ANTHROPIC_API_KEY=")) {
-              hasApiKey = true;
-              break;
-            }
-          }
-        }
-      } catch {
-      }
-    }
-    if (!hasApiKey) {
-      suggestions.push("Add ANTHROPIC_API_KEY to enable AI-powered analysis for better issue detection. Set in environment, .trie/config.json, or .env file");
-      score -= 10;
-    }
-    if (config.agents?.parallel === false) {
-      optimizations.push("Enable parallel agent execution for 3-5x faster scans");
-      score -= 15;
-    }
-    if (config.agents?.cache === false) {
-      optimizations.push("Enable result caching to speed up repeated scans");
-      score -= 10;
-    }
-    if (!config.compliance?.standards || config.compliance.standards.length === 0) {
-      suggestions.push("Configure compliance standards (SOC2, GDPR, etc.) for regulatory requirements");
-      score -= 5;
-    }
-    const hasIntegrations = config.integrations && (config.integrations.github?.enabled || config.integrations.slack?.enabled || config.integrations.jira?.enabled);
-    if (!hasIntegrations) {
-      suggestions.push("Consider enabling GitHub/Slack/JIRA integrations for better team collaboration");
-      score -= 5;
-    }
-    if (config.apiKeys) {
-      securityIssues.push("API keys in config file - consider using environment variables instead");
-      score -= 20;
-    }
-    return {
-      score: Math.max(0, score),
-      suggestions,
-      securityIssues,
-      optimizations
-    };
-  }
-};
-var DEFAULT_CONFIG = {
-  version: "1.0.0",
-  agents: {
-    enabled: [],
-    disabled: [],
-    parallel: true,
-    maxConcurrency: 4,
-    timeout: 12e4,
-    cache: true
-  },
-  compliance: {
-    standards: ["SOC2"],
-    enforceCompliance: false,
-    reportFormat: "json"
-  },
-  output: {
-    format: "console",
-    level: "all",
-    interactive: false,
-    streaming: true,
-    colors: true
-  },
-  paths: {
-    include: [],
-    exclude: ["node_modules", "dist", "build", ".git", ".next", ".nuxt", "coverage"],
-    configDir: ".trie",
-    outputDir: "trie-reports"
-  }
-};
-
-// src/config/loader.ts
-async function loadConfig() {
-  const validator = new ConfigValidator();
-  const configPath = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-  try {
-    if (!existsSync3(configPath)) {
-      return DEFAULT_CONFIG;
-    }
-    const configFile = await readFile(configPath, "utf-8");
-    const userConfig = JSON.parse(configFile);
-    const merged = mergeConfig(DEFAULT_CONFIG, userConfig);
-    const result = validator.validateConfig(merged);
-    if (!result.success) {
-      if (!isInteractiveMode()) {
-        console.error("Configuration validation failed:");
-        for (const error of result.errors) {
-          console.error(`  - ${error}`);
-        }
-      }
-      return DEFAULT_CONFIG;
-    }
-    if (!isInteractiveMode()) {
-      const envValidation = validator.validateEnvironment();
-      for (const warning of envValidation.warnings) {
-        console.warn(warning);
-      }
-      for (const error of envValidation.errors) {
-        console.error(error);
-      }
-    }
-    return result.data;
-  } catch (error) {
-    if (!isInteractiveMode()) {
-      console.error("Failed to load config, using defaults:", error);
-    }
-    return DEFAULT_CONFIG;
-  }
-}
-async function saveConfig(config) {
-  const configPath = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-  const dir = dirname(configPath);
-  if (!existsSync3(dir)) {
-    await mkdir(dir, { recursive: true });
-  }
-  await writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
-}
-function mergeConfig(defaults, user) {
-  if (typeof user !== "object" || user === null || Array.isArray(user)) {
-    return { ...defaults };
-  }
-  const result = { ...defaults };
-  for (const [key, value] of Object.entries(user)) {
-    const defaultValue = defaults[key];
-    if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof defaultValue === "object" && defaultValue !== null) {
-      result[key] = mergeConfig(defaultValue, value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-// src/orchestrator/triager.ts
-var Triager = class {
-  agentRegistry = getSkillRegistry();
-  config;
-  customSkillsLoaded = false;
-  contextState = null;
-  memoryInsights = null;
-  constructor(config) {
-    this.config = {
-      minConfidence: 0.15,
-      maxAgents: 11,
-      timeoutMs: 6e4,
-      enableCostAware: false,
-      enableDependencies: true,
-      ...config
-    };
-  }
-  /**
-   * Load previous context state for smart triaging
-   */
-  async loadPreviousContext() {
-    if (this.contextState === null) {
-      try {
-        this.contextState = await loadContextState();
-      } catch {
-        this.contextState = null;
-      }
-    }
-  }
-  /**
-   * Load memory insights for memory-influenced triaging
-   */
-  async loadMemoryInsights() {
-    if (this.memoryInsights !== null) return;
-    try {
-      const [stats, recent, historical, global] = await Promise.all([
-        getMemoryStats().catch(() => null),
-        getRecentIssues({ limit: 20 }).catch(() => []),
-        getHistoricalInsights(process.cwd()).catch(() => null),
-        getGlobalMemoryStats().catch(() => null)
-      ]);
-      const recentAgents = /* @__PURE__ */ new Set();
-      for (const issue of recent) {
-        recentAgents.add(issue.agent);
-      }
-      const recurringPatternAgents = /* @__PURE__ */ new Set();
-      if (historical?.recurringPatterns) {
-        for (const pattern of historical.recurringPatterns) {
-          recurringPatternAgents.add(pattern.agent);
-        }
-      }
-      const crossProjectAgents = /* @__PURE__ */ new Set();
-      if (global?.patternsByAgent) {
-        for (const [agent, count] of Object.entries(global.patternsByAgent)) {
-          if (count >= 2) {
-            crossProjectAgents.add(agent);
-          }
-        }
-      }
-      this.memoryInsights = {
-        issuesByAgent: stats?.issuesByAgent || {},
-        recentAgents,
-        recurringPatternAgents,
-        trend: historical?.improvementTrend || "unknown",
-        crossProjectAgents
-      };
-    } catch {
-      this.memoryInsights = {
-        issuesByAgent: {},
-        recentAgents: /* @__PURE__ */ new Set(),
-        recurringPatternAgents: /* @__PURE__ */ new Set(),
-        trend: "unknown",
-        crossProjectAgents: /* @__PURE__ */ new Set()
-      };
-    }
-  }
-  /**
-   * Ensure custom skills are loaded before triaging
-   */
-  async ensureCustomSkillsLoaded() {
-    if (!this.customSkillsLoaded) {
-      await this.agentRegistry.loadCustomSkills();
-      this.customSkillsLoaded = true;
-    }
-  }
-  async selectAgents(context, riskLevel) {
-    await this.ensureCustomSkillsLoaded();
-    await Promise.all([
-      this.loadPreviousContext(),
-      this.loadMemoryInsights()
-    ]);
-    let effectiveRiskLevel = riskLevel;
-    if (this.contextState?.healthScore !== void 0 && this.contextState.healthScore < 50) {
-      if (riskLevel === "low" || riskLevel === "medium") {
-        effectiveRiskLevel = "high";
-        if (!isInteractiveMode()) {
-          console.error(`   Health score ${this.contextState.healthScore}% - escalating to ${effectiveRiskLevel.toUpperCase()} risk`);
-        }
-      }
-    }
-    if (effectiveRiskLevel === "critical" || effectiveRiskLevel === "high") {
-      if (!isInteractiveMode()) {
-        console.error(`   ${effectiveRiskLevel.toUpperCase()} risk - activating all scouts for comprehensive review`);
-      }
-      return this.getAllAgents().filter((agent) => agent.shouldActivate(context));
-    }
-    const scores = this.scoreAgents(context, effectiveRiskLevel);
-    this.boostAgentsWithHistory(scores);
-    this.boostAgentsWithMemory(scores);
-    this.logAgentScoring(scores);
-    const qualified = scores.filter((s) => s.confidence >= this.config.minConfidence);
-    qualified.sort((a, b) => {
-      if (a.tier !== b.tier) return a.tier - b.tier;
-      return b.confidence - a.confidence;
-    });
-    if (this.config.enableDependencies) {
-      return this.resolveDependencies(qualified.map((s) => s.agent));
-    }
-    return qualified.map((s) => s.agent);
-  }
-  /**
-   * Boost confidence for agents that found issues in previous scans
-   */
-  boostAgentsWithHistory(scores) {
-    if (!this.contextState?.agentStatus) return;
-    for (const score of scores) {
-      const previousRun = this.contextState.agentStatus[score.agent.name];
-      if (previousRun?.issuesFound && previousRun.issuesFound > 0) {
-        const boost = Math.min(0.3, previousRun.issuesFound * 0.05);
-        score.confidence = Math.min(1, score.confidence + boost);
-        score.reasons.push(`found ${previousRun.issuesFound} issues in last scan`);
-      }
-    }
-  }
-  /**
-   * Boost confidence for agents based on memory patterns
-   */
-  boostAgentsWithMemory(scores) {
-    if (!this.memoryInsights) return;
-    for (const score of scores) {
-      const agentName = score.agent.name;
-      const historicalCount = this.memoryInsights.issuesByAgent[agentName] || 0;
-      if (historicalCount >= 10) {
-        const boost = Math.min(0.2, historicalCount * 0.01);
-        score.confidence = Math.min(1, score.confidence + boost);
-        score.reasons.push(`${historicalCount} historical issues`);
-      }
-      if (this.memoryInsights.recentAgents.has(agentName)) {
-        score.confidence = Math.min(1, score.confidence + 0.1);
-        score.reasons.push("recent activity");
-      }
-      if (this.memoryInsights.recurringPatternAgents.has(agentName)) {
-        score.confidence = Math.min(1, score.confidence + 0.15);
-        score.reasons.push("recurring patterns");
-      }
-      if (this.memoryInsights.crossProjectAgents.has(agentName)) {
-        score.confidence = Math.min(1, score.confidence + 0.1);
-        score.reasons.push("cross-project pattern");
-      }
-    }
-    if (this.memoryInsights.trend === "declining") {
-      for (const score of scores) {
-        if (score.confidence > 0) {
-          score.confidence = Math.min(1, score.confidence + 0.05);
-        }
-      }
-    }
-  }
-  scoreAgents(context, riskLevel) {
-    const allAgents = this.getAllAgents();
-    const scores = [];
-    for (const agent of allAgents) {
-      const score = this.scoreAgent(agent, context, riskLevel);
-      scores.push(score);
-    }
-    return scores;
-  }
-  scoreAgent(agent, context, riskLevel) {
-    if (agent instanceof CustomSkill) {
-      return this.scoreCustomSkill(agent, context, riskLevel);
-    }
-    return this.scoreBuiltinAgent(agent, context, riskLevel);
-  }
-  /**
-   * Score custom skills using their activation rules
-   */
-  scoreCustomSkill(agent, context, riskLevel) {
-    const reasons = [];
-    let confidence = agent.getActivationConfidence(context);
-    if (confidence > 0) {
-      reasons.push(`custom skill: ${agent.getMetadata().category}`);
-      const meta = agent.getMetadata();
-      if (meta.patternCount > 0) {
-        reasons.push(`${meta.patternCount} detection patterns`);
-      }
-    }
-    if (riskLevel === "high" && confidence > 0) {
-      confidence = Math.min(1, confidence * 1.2);
-    }
-    return {
-      agent,
-      confidence,
-      reasons,
-      tier: agent.priority.tier,
-      isCustom: true
-    };
-  }
-  /**
-   * Score built-in agents
-   */
-  scoreBuiltinAgent(agent, context, riskLevel) {
-    const reasons = [];
-    let confidence = 0;
-    let tier = 3;
-    if (agent.name === "typecheck") {
-      tier = 1;
-      confidence = 1;
-      reasons.push("fundamental type safety");
-    }
-    if (agent.name === "comprehension") {
-      tier = 1;
-      confidence = 1;
-      reasons.push("stakeholder communication");
-    }
-    if (agent.name === "security") {
-      tier = 2;
-      if (context.touchesAuth) {
-        confidence += 0.4;
-        reasons.push("auth code");
-      }
-      if (context.touchesPayments) {
-        confidence += 0.4;
-        reasons.push("payment code");
-      }
-      if (context.touchesAPI) {
-        confidence += 0.3;
-        reasons.push("API endpoints");
-      }
-      if (context.touchesDatabase) {
-        confidence += 0.25;
-        reasons.push("database access");
-      }
-      if (context.touchesCrypto) {
-        confidence += 0.35;
-        reasons.push("cryptographic operations");
-      }
-      if (context.touchesUserData) {
-        confidence += 0.3;
-        reasons.push("user data");
-      }
-      if (context.touchesSecurityConfig) {
-        confidence += 0.4;
-        reasons.push("security config");
-      }
-      if (context.touchesThirdPartyAPI) {
-        confidence += 0.2;
-        reasons.push("third-party integration");
-      }
-      if (context.patterns?.hasFileUploads) {
-        confidence += 0.3;
-        reasons.push("file uploads");
-      }
-      if (riskLevel === "high") confidence *= 1.2;
-    }
-    if (agent.name === "privacy") {
-      tier = 2;
-      if (context.touchesUserData) {
-        confidence += 0.5;
-        reasons.push("PII handling");
-      }
-      if (context.touchesAuth) {
-        confidence += 0.3;
-        reasons.push("credentials");
-      }
-      if (context.touchesLogging) {
-        confidence += 0.25;
-        reasons.push("logging (may expose data)");
-      }
-      if (context.patterns?.hasEmailHandling) {
-        confidence += 0.3;
-        reasons.push("email handling");
-      }
-      if (context.patterns?.hasFormHandling) {
-        confidence += 0.2;
-        reasons.push("form data");
-      }
-    }
-    if (agent.name === "legal") {
-      tier = 2;
-      if (context.touchesUserData) {
-        confidence += 0.4;
-        reasons.push("GDPR/CCPA");
-      }
-      if (context.touchesPayments) {
-        confidence += 0.35;
-        reasons.push("PCI-DSS");
-      }
-      if (context.patterns?.hasEmailHandling) {
-        confidence += 0.25;
-        reasons.push("CAN-SPAM");
-      }
-    }
-    if (agent.name === "accessibility") {
-      tier = 2;
-      if (context.touchesUI) {
-        confidence += 0.6;
-        reasons.push("UI components");
-      }
-      if (context.framework === "react" || context.framework === "vue") {
-        confidence += 0.2;
-        reasons.push(`${context.framework} framework`);
-      }
-      if (context.patterns?.hasFormHandling) {
-        confidence += 0.2;
-        reasons.push("form UX");
-      }
-    }
-    if (agent.name === "test") {
-      tier = 2;
-      if (context.isNewFeature) {
-        confidence += 0.4;
-        reasons.push("new feature");
-      }
-      if (context.touchesAuth) {
-        confidence += 0.35;
-        reasons.push("auth needs tests");
-      }
-      if (context.touchesPayments) {
-        confidence += 0.4;
-        reasons.push("payments need tests");
-      }
-      if (context.touchesAPI) {
-        confidence += 0.3;
-        reasons.push("API testing");
-      }
-      if (!context.hasTests) {
-        confidence += 0.2;
-        reasons.push("no existing tests");
-      }
-      if (context.complexity === "high") {
-        confidence += 0.25;
-        reasons.push("complex code");
-      }
-    }
-    if (agent.name === "software-architect") {
-      tier = 2;
-      if (context.isNewFeature) {
-        confidence += 0.35;
-        reasons.push("architecture review");
-      }
-      if (context.touchesDatabase) {
-        confidence += 0.35;
-        reasons.push("data modeling");
-      }
-      if (context.linesChanged > 200) {
-        confidence += 0.3;
-        reasons.push("large change");
-      }
-      if (context.touchesAPI) {
-        confidence += 0.25;
-        reasons.push("API design");
-      }
-      if (context.patterns?.hasWebSockets) {
-        confidence += 0.3;
-        reasons.push("real-time architecture");
-      }
-      if (context.patterns?.hasQueue) {
-        confidence += 0.3;
-        reasons.push("async architecture");
-      }
-    }
-    if (agent.name === "devops") {
-      tier = 2;
-      if (context.touchesSecurityConfig) {
-        confidence += 0.4;
-        reasons.push("security config");
-      }
-      if (context.touchesFileSystem) {
-        confidence += 0.3;
-        reasons.push("file operations");
-      }
-      if (context.touchesLogging) {
-        confidence += 0.25;
-        reasons.push("logging");
-      }
-      if (context.touchesErrorHandling) {
-        confidence += 0.2;
-        reasons.push("error handling");
-      }
-      if (context.patterns?.hasCaching) {
-        confidence += 0.25;
-        reasons.push("caching");
-      }
-      if (context.patterns?.hasRateLimiting) {
-        confidence += 0.3;
-        reasons.push("rate limiting");
-      }
-    }
-    if (agent.name === "bug-finding") {
-      tier = 2;
-      if (context.touchesPayments) {
-        confidence += 0.5;
-        reasons.push("payments = zero bugs");
-      }
-      if (context.isNewFeature) {
-        confidence += 0.3;
-        reasons.push("new code");
-      }
-      if (context.patterns?.hasAsyncCode) {
-        confidence += 0.35;
-        reasons.push("async patterns");
-      }
-      if (context.complexity === "high") {
-        confidence += 0.3;
-        reasons.push("complex logic");
-      }
-      if (context.touchesDatabase) {
-        confidence += 0.25;
-        reasons.push("data mutations");
-      }
-    }
-    if (agent.name === "user-testing") {
-      tier = 3;
-      if (context.touchesUI) {
-        confidence += 0.5;
-        reasons.push("UI changes");
-      }
-      if (context.isNewFeature && context.touchesUI) {
-        confidence += 0.3;
-        reasons.push("new UI feature");
-      }
-      if (context.patterns?.hasFormHandling) {
-        confidence += 0.25;
-        reasons.push("form UX");
-      }
-    }
-    if (agent.name === "trie_clean") {
-      tier = 2;
-      if (context.touchesUI) {
-        confidence += 0.4;
-        reasons.push("UI code");
-      }
-      if (context.isNewFeature) {
-        confidence += 0.3;
-        reasons.push("new feature");
-      }
-      if (context.framework === "react") {
-        confidence += 0.2;
-        reasons.push("React code");
-      }
-    }
-    if (agent.name === "soc2") {
-      tier = 2;
-      if (context.touchesAuth) {
-        confidence += 0.4;
-        reasons.push("authentication");
-      }
-      if (context.touchesSecurityConfig) {
-        confidence += 0.4;
-        reasons.push("security config");
-      }
-      if (context.touchesLogging) {
-        confidence += 0.3;
-        reasons.push("logging");
-      }
-      if (context.touchesAPI) {
-        confidence += 0.25;
-        reasons.push("API endpoints");
-      }
-      if (context.touchesDatabase) {
-        confidence += 0.2;
-        reasons.push("data access");
-      }
-    }
-    if (agent.name === "moneybags") {
-      tier = 3;
-      if (context.touchesPayments) {
-        confidence += 0.6;
-        reasons.push("payment code = high cost risk");
-      }
-      if (context.touchesAuth) {
-        confidence += 0.4;
-        reasons.push("auth bugs are expensive");
-      }
-      if (context.touchesHealthData) {
-        confidence += 0.5;
-        reasons.push("HIPAA violations");
-      }
-      if (context.touchesUserData) {
-        confidence += 0.3;
-        reasons.push("PII exposure costs");
-      }
-      if (context.touchesDatabase) {
-        confidence += 0.25;
-        reasons.push("data loss risk");
-      }
-      if (context.isNewFeature) {
-        confidence += 0.2;
-        reasons.push("new code risk");
-      }
-      if (riskLevel === "high" || riskLevel === "critical") {
-        confidence *= 1.3;
-        reasons.push("high-stakes context");
-      }
-    }
-    if (agent.name === "production-ready") {
-      tier = 3;
-      if (context.touchesAPI) {
-        confidence += 0.4;
-        reasons.push("API deployment");
-      }
-      if (context.touchesDatabase) {
-        confidence += 0.35;
-        reasons.push("database operations");
-      }
-      if (context.touchesAuth) {
-        confidence += 0.35;
-        reasons.push("auth system");
-      }
-      if (context.touchesPayments) {
-        confidence += 0.5;
-        reasons.push("payment processing");
-      }
-      if (context.linesChanged > 200) {
-        confidence += 0.3;
-        reasons.push("significant changes");
-      }
-      if (riskLevel === "high" || riskLevel === "critical") {
-        confidence += 0.4;
-        reasons.push("production gate check");
-      }
-    }
-    confidence = Math.min(1, confidence);
-    return { agent, confidence, reasons, tier, isCustom: false };
-  }
-  logAgentScoring(scores) {
-    if (isInteractiveMode()) return;
-    console.error("\n   Agent Confidence Scores:");
-    const sorted = [...scores].sort((a, b) => b.confidence - a.confidence);
-    for (const score of sorted) {
-      const bar = this.getConfidenceBar(score.confidence);
-      const status = score.confidence >= this.config.minConfidence ? "\u2713" : "\u2717";
-      const tierLabel = score.tier === 1 ? "[T1]" : score.tier === 2 ? "[T2]" : "[T3]";
-      const customLabel = score.isCustom ? " \u{1F4DA}" : "";
-      console.error(`      ${status} ${score.agent.name.padEnd(18)} ${tierLabel} ${bar} ${(score.confidence * 100).toFixed(0)}%${customLabel}`);
-      if (score.reasons.length > 0 && score.confidence > 0) {
-        console.error(`        \u2514\u2500 ${score.reasons.join(", ")}`);
-      }
-    }
-    console.error("");
-  }
-  getConfidenceBar(confidence) {
-    const filled = Math.round(confidence * 10);
-    const empty = 10 - filled;
-    return "\u2588".repeat(filled) + "\u2591".repeat(empty);
-  }
-  resolveDependencies(agents) {
-    const agentNames = new Set(agents.map((a) => a.name));
-    const resolved = [];
-    const added = /* @__PURE__ */ new Set();
-    const dependencies = {
-      "legal": ["privacy"],
-      // legal should see privacy issues first
-      "test": ["bug-finding"],
-      // find bugs before writing tests
-      "user-testing": ["accessibility"]
-      // accessibility before UX
-    };
-    for (const agent of agents) {
-      const deps = dependencies[agent.name] || [];
-      for (const depName of deps) {
-        if (!added.has(depName)) {
-          const depAgent = this.agentRegistry.getAgent(depName);
-          if (depAgent && agentNames.has(depName)) {
-            resolved.push(depAgent);
-            added.add(depName);
-          }
-        }
-      }
-      if (!added.has(agent.name)) {
-        resolved.push(agent);
-        added.add(agent.name);
-      }
-    }
-    return resolved;
-  }
-  getTriagingReason(context, riskLevel) {
-    if (riskLevel === "critical") {
-      return "Critical risk detected - activating all scouts for comprehensive review";
-    }
-    const reasons = [];
-    if (context.touchesAuth) reasons.push("authentication");
-    if (context.touchesPayments) reasons.push("payments");
-    if (context.touchesDatabase) reasons.push("database");
-    if (context.touchesUserData) reasons.push("user data");
-    if (context.touchesUI) reasons.push("UI");
-    if (context.touchesAPI) reasons.push("API");
-    if (context.isNewFeature) reasons.push("new feature");
-    if (context.touchesCrypto) reasons.push("cryptography");
-    if (context.touchesThirdPartyAPI) reasons.push("3rd party API");
-    if (reasons.length === 0) {
-      return `${riskLevel} risk - general code changes`;
-    }
-    return `${riskLevel} risk: ${reasons.join(", ")}`;
-  }
-  async getSkippedAgents(context, riskLevel) {
-    await this.ensureCustomSkillsLoaded();
-    if (riskLevel === "critical") return [];
-    const scores = this.scoreAgents(context, riskLevel);
-    return scores.filter((s) => s.confidence < this.config.minConfidence).map((s) => s.agent.name);
-  }
-  async getTriagingConfidence(context, riskLevel) {
-    await this.ensureCustomSkillsLoaded();
-    const scores = this.scoreAgents(context, riskLevel);
-    const qualified = scores.filter((s) => s.confidence >= this.config.minConfidence);
-    if (qualified.length === 0) return 0.5;
-    const avgConfidence = qualified.reduce((sum, s) => sum + s.confidence, 0) / qualified.length;
-    const contextStrength = this.getContextStrength(context);
-    return Math.min(1, avgConfidence * 0.7 + contextStrength * 0.3);
-  }
-  getContextStrength(context) {
-    let signals = 0;
-    const checks = [
-      context.touchesAuth,
-      context.touchesPayments,
-      context.touchesDatabase,
-      context.touchesAPI,
-      context.touchesUI,
-      context.touchesUserData,
-      context.touchesHealthData,
-      context.touchesSecurityConfig,
-      context.touchesCrypto,
-      context.touchesFileSystem,
-      context.isNewFeature
-    ];
-    for (const check of checks) {
-      if (check) signals++;
-    }
-    return signals > 0 ? Math.min(1, signals / 3) : 0.3;
-  }
-  getAllAgents() {
-    return this.agentRegistry.getAllAgents();
-  }
-  /**
-   * Get custom skills count
-   */
-  getCustomSkillCount() {
-    return this.agentRegistry.getCustomSkills().length;
-  }
-  // Backward compatibility alias
-  getCustomAgentCount() {
-    return this.getCustomSkillCount();
-  }
-  /**
-   * Reload custom skills
-   */
-  async reloadCustomSkills() {
-    await this.agentRegistry.reloadCustomSkills();
-  }
-  // Backward compatibility alias
-  async reloadCustomAgents() {
-    return this.reloadCustomSkills();
-  }
-};
-
-// src/utils/parallel-executor.ts
-import { Worker } from "worker_threads";
-import { cpus } from "os";
-import { existsSync as existsSync4 } from "fs";
-import { fileURLToPath } from "url";
-var ParallelExecutor = class {
-  maxWorkers;
-  cache;
-  streaming;
-  activeWorkers = /* @__PURE__ */ new Set();
-  cacheEnabled = true;
-  useWorkerThreads = false;
-  workerAvailable = null;
-  warnedWorkerFallback = false;
-  constructor(cacheManager, maxWorkers = Math.max(2, Math.min(cpus().length - 1, 8)), options) {
-    this.maxWorkers = maxWorkers;
-    this.cache = cacheManager;
-    this.cacheEnabled = options?.cacheEnabled ?? true;
-    this.useWorkerThreads = options?.useWorkerThreads ?? false;
-  }
-  /**
-   * Set streaming manager for real-time updates
-   */
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  /**
-   * Execute agents in parallel with intelligent scheduling
-   */
-  async executeAgents(agents, files, context) {
-    if (agents.length === 0) {
-      return /* @__PURE__ */ new Map();
-    }
-    if (this.streaming && this.streaming.getProgress().totalFiles === 0) {
-      this.streaming.startScan(files.length);
-    }
-    const cacheResults = /* @__PURE__ */ new Map();
-    const uncachedTasks = [];
-    for (const agent of agents) {
-      const cached = await this.checkAgentCache(agent, files);
-      if (cached) {
-        cacheResults.set(agent.name, cached);
-        this.streaming?.completeAgent(agent.name, cached.issues);
-      } else {
-        uncachedTasks.push({
-          agent,
-          files,
-          context,
-          priority: agent.priority?.tier || 2,
-          timeoutMs: context?.config?.timeoutMs || 12e4
-        });
-      }
-    }
-    uncachedTasks.sort((a, b) => a.priority - b.priority);
-    const parallelResults = await this.executeTasksParallel(uncachedTasks);
-    await this.cacheResults(parallelResults);
-    const allResults = /* @__PURE__ */ new Map();
-    for (const [agent, result] of cacheResults) {
-      allResults.set(agent, result);
-    }
-    for (const result of parallelResults) {
-      allResults.set(result.agent, result.result);
-    }
-    const allIssues = Array.from(allResults.values()).flatMap((r) => r.issues);
-    this.streaming?.completeScan(allIssues);
-    return allResults;
-  }
-  /**
-   * Check if agent has cached results for given files
-   */
-  async checkAgentCache(agent, files) {
-    if (!this.cacheEnabled || !this.cache) {
-      return null;
-    }
-    const cachedIssues = await this.cache.getCachedBatch(files, agent.name);
-    if (cachedIssues.size === files.length) {
-      const allIssues = Array.from(cachedIssues.values()).flat();
-      return {
-        agent: agent.name,
-        issues: allIssues,
-        executionTime: 0,
-        // Cached
-        success: true,
-        metadata: {
-          filesAnalyzed: files.length,
-          linesAnalyzed: 0
-        }
-      };
-    }
-    return null;
-  }
-  /**
-   * Execute tasks in parallel batches
-   */
-  async executeTasksParallel(tasks) {
-    if (tasks.length === 0) {
-      return [];
-    }
-    const results = [];
-    const batches = this.createBatches(tasks, this.maxWorkers);
-    for (const batch of batches) {
-      const batchResults = await Promise.all(
-        batch.map((task) => this.executeTask(task))
-      );
-      results.push(...batchResults);
-    }
-    return results;
-  }
-  /**
-   * Create batches for parallel execution
-   */
-  createBatches(tasks, batchSize) {
-    const batches = [];
-    for (let i = 0; i < tasks.length; i += batchSize) {
-      batches.push(tasks.slice(i, i + batchSize));
-    }
-    return batches;
-  }
-  /**
-   * Execute a single task
-   */
-  async executeTask(task) {
-    const startTime = Date.now();
-    this.streaming?.startAgent(task.agent.name);
-    try {
-      const result = this.canUseWorkers() ? await this.executeTaskInWorker(task) : await task.agent.scan(task.files, task.context);
-      const executionTime = Date.now() - startTime;
-      this.streaming?.completeAgent(task.agent.name, result.issues);
-      return {
-        agent: task.agent.name,
-        result,
-        fromCache: false,
-        executionTime
-      };
-    } catch (error) {
-      const executionTime = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.streaming?.reportError(new Error(errorMessage), `Agent: ${task.agent.name}`);
-      return {
-        agent: task.agent.name,
-        result: {
-          agent: task.agent.name,
-          issues: [],
-          executionTime,
-          success: false,
-          error: errorMessage
-        },
-        fromCache: false,
-        executionTime
-      };
-    }
-  }
-  canUseWorkers() {
-    if (!this.useWorkerThreads) {
-      return false;
-    }
-    if (this.workerAvailable !== null) {
-      return this.workerAvailable;
-    }
-    const workerUrl = this.getWorkerUrl();
-    this.workerAvailable = existsSync4(fileURLToPath(workerUrl));
-    if (!this.workerAvailable && !this.warnedWorkerFallback && !isInteractiveMode()) {
-      console.error("Worker threads unavailable; falling back to in-process agents.");
-      this.warnedWorkerFallback = true;
-    }
-    return this.workerAvailable;
-  }
-  getWorkerUrl() {
-    const distDir = new URL(".", import.meta.url);
-    return new URL("workers/agent-worker.js", distDir);
-  }
-  async executeTaskInWorker(task) {
-    const workerUrl = this.getWorkerUrl();
-    return new Promise((resolve2, reject) => {
-      const worker = new Worker(workerUrl, {
-        workerData: {
-          agentName: task.agent.name,
-          files: task.files,
-          context: task.context
-        }
-      });
-      this.activeWorkers.add(worker);
-      const timeout = setTimeout(() => {
-        worker.terminate().catch(() => void 0);
-        reject(new Error(`Agent ${task.agent.name} timed out after ${task.timeoutMs}ms`));
-      }, task.timeoutMs);
-      worker.on("message", (message) => {
-        if (message?.type === "result") {
-          clearTimeout(timeout);
-          resolve2(message.result);
-        } else if (message?.type === "error") {
-          clearTimeout(timeout);
-          reject(new Error(message.error));
-        }
-      });
-      worker.on("error", (error) => {
-        clearTimeout(timeout);
-        reject(error);
-      });
-      worker.on("exit", (code) => {
-        this.activeWorkers.delete(worker);
-        if (code !== 0) {
-          clearTimeout(timeout);
-          reject(new Error(`Worker stopped with exit code ${code}`));
-        }
-      });
-    });
-  }
-  /**
-   * Cache results for future use
-   */
-  async cacheResults(results) {
-    if (!this.cacheEnabled || !this.cache) {
-      return;
-    }
-    const cachePromises = results.filter((r) => r.result.success && !r.fromCache).map((r) => {
-      const issuesByFile = this.groupIssuesByFile(r.result.issues);
-      const perFilePromises = Object.entries(issuesByFile).map(
-        ([file, issues]) => this.cache.setCached(file, r.agent, issues, r.executionTime)
-      );
-      return Promise.all(perFilePromises);
-    });
-    await Promise.allSettled(cachePromises);
-  }
-  /**
-   * Cleanup resources
-   */
-  async cleanup() {
-    const terminationPromises = Array.from(this.activeWorkers).map(
-      (worker) => worker.terminate()
-    );
-    await Promise.allSettled(terminationPromises);
-    this.activeWorkers.clear();
-  }
-  groupIssuesByFile(issues) {
-    const grouped = {};
-    for (const issue of issues) {
-      if (!grouped[issue.file]) {
-        grouped[issue.file] = [];
-      }
-      grouped[issue.file].push(issue);
-    }
-    return grouped;
-  }
-};
-function calculateOptimalConcurrency() {
-  const numCPUs = cpus().length;
-  const availableMemoryGB = process.memoryUsage().rss / 1024 / 1024 / 1024;
-  let optimal = Math.max(2, Math.min(numCPUs - 1, 8));
-  if (availableMemoryGB < 2) {
-    optimal = Math.max(2, Math.floor(optimal / 2));
-  }
-  if (numCPUs > 8) {
-    optimal = Math.min(optimal + 2, 12);
-  }
-  return optimal;
-}
-
-// src/orchestrator/executor.ts
-var Executor = class {
-  async executeAgents(agents, files, context, options) {
-    const parallel = options?.parallel ?? true;
-    const cacheEnabled = options?.cacheEnabled ?? true;
-    const maxConcurrency = options?.maxConcurrency ?? calculateOptimalConcurrency();
-    const useWorkerThreads = options?.useWorkerThreads ?? false;
-    if (!isInteractiveMode()) {
-      console.error(`Executing ${agents.length} scouts ${parallel ? "in parallel" : "sequentially"}...`);
-    }
-    if (parallel) {
-      const cacheManager = cacheEnabled ? new CacheManager(context.workingDir) : null;
-      const executor = new ParallelExecutor(cacheManager, maxConcurrency, {
-        cacheEnabled,
-        useWorkerThreads
-      });
-      if (options?.streaming) {
-        executor.setStreaming(options.streaming);
-      }
-      const results = await executor.executeAgents(agents, files, {
-        ...context,
-        config: { timeoutMs: options?.timeoutMs ?? 12e4 }
-      });
-      return agents.map((agent) => results.get(agent.name)).filter(Boolean);
-    }
-    const promises = agents.map(
-      (agent) => this.executeAgentWithTimeout(agent, files, context, options?.timeoutMs ?? 3e4)
-    );
-    try {
-      const results = await Promise.allSettled(promises);
-      return results.map((result, index) => {
-        if (result.status === "fulfilled") {
-          if (!isInteractiveMode()) {
-            console.error(`${agents[index].name} completed in ${result.value.executionTime}ms`);
-          }
-          return result.value;
-        } else {
-          if (!isInteractiveMode()) {
-            console.error(`${agents[index].name} failed:`, result.reason);
-          }
-          return {
-            agent: agents[index].name,
-            issues: [],
-            executionTime: 0,
-            success: false,
-            error: result.reason instanceof Error ? result.reason.message : String(result.reason)
-          };
-        }
-      });
-    } catch (error) {
-      if (!isInteractiveMode()) {
-        console.error("Executor error:", error);
-      }
-      return agents.map((agent) => ({
-        agent: agent.name,
-        issues: [],
-        executionTime: 0,
-        success: false,
-        error: "Execution failed"
-      }));
-    }
-  }
-  async executeAgentWithTimeout(agent, files, context, timeoutMs = 3e4) {
-    return new Promise(async (resolve2, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error(`Agent ${agent.name} timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      try {
-        const result = await agent.scan(files, context);
-        clearTimeout(timeout);
-        resolve2(result);
-      } catch (error) {
-        clearTimeout(timeout);
-        reject(error);
-      }
-    });
-  }
-};
-
-// src/bootstrap/stack-detector.ts
-import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join4 } from "path";
-var SKILL_MAPPINGS = {
-  // Frontend Frameworks - React/Next.js
-  "next": [
-    "vercel-labs/agent-skills vercel-react-best-practices",
-    "vercel-labs/agent-skills web-design-guidelines",
-    "anthropics/skills frontend-design",
-    "wshobson/agents nextjs-app-router-patterns"
-  ],
-  "react": [
-    "vercel-labs/agent-skills vercel-react-best-practices",
-    "anthropics/skills frontend-design",
-    "wshobson/agents react-state-management"
-  ],
-  // Vue/Nuxt Ecosystem
-  "vue": [
-    "hyf0/vue-skills vue-best-practices",
-    "hyf0/vue-skills pinia-best-practices",
-    "hyf0/vue-skills vueuse-best-practices",
-    "onmax/nuxt-skills vue"
-  ],
-  "nuxt": [
-    "onmax/nuxt-skills nuxt",
-    "onmax/nuxt-skills nuxt-ui",
-    "onmax/nuxt-skills nuxt-content",
-    "onmax/nuxt-skills nuxt-modules",
-    "onmax/nuxt-skills nuxt-better-auth",
-    "onmax/nuxt-skills nuxthub"
-  ],
-  "pinia": [
-    "hyf0/vue-skills pinia-best-practices"
-  ],
-  "@vueuse/core": [
-    "hyf0/vue-skills vueuse-best-practices",
-    "onmax/nuxt-skills vueuse"
-  ],
-  // Mobile - Expo
-  "expo": [
-    "expo/skills building-native-ui",
-    "expo/skills upgrading-expo",
-    "expo/skills native-data-fetching",
-    "expo/skills expo-dev-client",
-    "expo/skills expo-deployment",
-    "expo/skills expo-api-routes",
-    "expo/skills expo-tailwind-setup",
-    "expo/skills expo-cicd-workflows",
-    "expo/skills use-dom"
-  ],
-  // Mobile - React Native
-  "react-native": [
-    "callstackincubator/agent-skills react-native-best-practices",
-    "wshobson/agents react-native-architecture"
-  ],
-  // Backend Frameworks
-  "@nestjs/core": [
-    "kadajett/agent-nestjs-skills nestjs-best-practices"
-  ],
-  "nestjs": [
-    "kadajett/agent-nestjs-skills nestjs-best-practices"
-  ],
-  "elysia": [
-    "elysiajs/skills elysiajs"
-  ],
-  "hono": [
-    "elysiajs/skills elysiajs"
-  ],
-  // Database/BaaS
-  "@supabase/supabase-js": [
-    "supabase/agent-skills supabase-postgres-best-practices"
-  ],
-  "convex": [
-    "waynesutton/convexskills convex-best-practices"
-  ],
-  "pg": [
-    "wshobson/agents postgresql-table-design"
-  ],
-  "postgres": [
-    "wshobson/agents postgresql-table-design"
-  ],
-  // Auth
-  "better-auth": [
-    "better-auth/skills better-auth-best-practices",
-    "better-auth/skills create-auth-skill"
-  ],
-  // Payments
-  "stripe": [
-    "stripe/ai stripe-best-practices"
-  ],
-  "@stripe/stripe-js": [
-    "stripe/ai stripe-best-practices"
-  ],
-  // Media/Graphics
-  "remotion": [
-    "remotion-dev/skills remotion-best-practices"
-  ],
-  "three": [
-    "cloudai-x/threejs-skills threejs-fundamentals",
-    "cloudai-x/threejs-skills threejs-animation",
-    "cloudai-x/threejs-skills threejs-materials",
-    "cloudai-x/threejs-skills threejs-shaders",
-    "cloudai-x/threejs-skills threejs-lighting",
-    "cloudai-x/threejs-skills threejs-geometry",
-    "cloudai-x/threejs-skills threejs-textures",
-    "cloudai-x/threejs-skills threejs-loaders",
-    "cloudai-x/threejs-skills threejs-interaction",
-    "cloudai-x/threejs-skills threejs-postprocessing"
-  ],
-  // UI Libraries
-  "tailwindcss": [
-    "wshobson/agents tailwind-design-system",
-    "jezweb/claude-skills tailwind-v4-shadcn",
-    "wshobson/agents responsive-design"
-  ],
-  "@shadcn/ui": [
-    "giuseppe-trisciuoglio/developer-kit shadcn-ui"
-  ],
-  "shadcn": [
-    "giuseppe-trisciuoglio/developer-kit shadcn-ui"
-  ],
-  "@radix-ui/react-slot": [
-    "onmax/nuxt-skills reka-ui"
-  ],
-  // State Management
-  "@tanstack/react-query": [
-    "jezweb/claude-skills tanstack-query"
-  ],
-  // Testing
-  "playwright": [
-    "anthropics/skills webapp-testing",
-    "wshobson/agents e2e-testing-patterns"
-  ],
-  "puppeteer": [
-    "anthropics/skills webapp-testing"
-  ],
-  "vitest": [
-    "wshobson/agents e2e-testing-patterns"
-  ],
-  "jest": [
-    "wshobson/agents e2e-testing-patterns"
-  ],
-  // DevTools/MCP
-  "@modelcontextprotocol/sdk": [
-    "anthropics/skills mcp-builder"
-  ],
-  // Security
-  "semgrep": [
-    "trailofbits/skills semgrep"
-  ],
-  // Monorepos
-  "turbo": [
-    "wshobson/agents monorepo-management"
-  ],
-  "nx": [
-    "wshobson/agents monorepo-management"
-  ],
-  "lerna": [
-    "wshobson/agents monorepo-management"
-  ],
-  // TypeScript (handled separately based on tsconfig.json)
-  "typescript": [
-    "wshobson/agents typescript-advanced-types"
-  ]
-};
-var SKILL_CATEGORIES = {
-  documents: [
-    "anthropics/skills pdf",
-    "anthropics/skills xlsx",
-    "anthropics/skills pptx",
-    "anthropics/skills docx",
-    "anthropics/skills doc-coauthoring"
-  ],
-  design: [
-    "anthropics/skills canvas-design",
-    "anthropics/skills theme-factory",
-    "anthropics/skills web-artifacts-builder",
-    "anthropics/skills algorithmic-art",
-    "anthropics/skills brand-guidelines",
-    "anthropics/skills slack-gif-creator",
-    "nextlevelbuilder/ui-ux-pro-max ui-ux-pro-max",
-    "superdesigndev/superdesign-skill superdesign",
-    "wshobson/agents design-system-patterns"
-  ],
-  marketing: [
-    "coreyhaines31/marketingskills seo-audit",
-    "coreyhaines31/marketingskills copywriting",
-    "coreyhaines31/marketingskills marketing-psychology",
-    "coreyhaines31/marketingskills programmatic-seo",
-    "coreyhaines31/marketingskills marketing-ideas",
-    "coreyhaines31/marketingskills copy-editing",
-    "coreyhaines31/marketingskills pricing-strategy",
-    "coreyhaines31/marketingskills social-content",
-    "coreyhaines31/marketingskills launch-strategy",
-    "coreyhaines31/marketingskills page-cro",
-    "coreyhaines31/marketingskills competitor-alternatives",
-    "coreyhaines31/marketingskills analytics-tracking",
-    "coreyhaines31/marketingskills schema-markup",
-    "coreyhaines31/marketingskills onboarding-cro",
-    "coreyhaines31/marketingskills email-sequence",
-    "coreyhaines31/marketingskills paid-ads",
-    "coreyhaines31/marketingskills signup-flow-cro",
-    "coreyhaines31/marketingskills free-tool-strategy",
-    "coreyhaines31/marketingskills form-cro",
-    "coreyhaines31/marketingskills paywall-upgrade-cro",
-    "coreyhaines31/marketingskills referral-program",
-    "coreyhaines31/marketingskills popup-cro",
-    "coreyhaines31/marketingskills ab-test-setup"
-  ],
-  development: [
-    "obra/superpowers brainstorming",
-    "obra/superpowers test-driven-development",
-    "obra/superpowers systematic-debugging",
-    "obra/superpowers writing-plans",
-    "obra/superpowers executing-plans",
-    "obra/superpowers verification-before-completion",
-    "obra/superpowers using-superpowers",
-    "obra/superpowers subagent-driven-development",
-    "obra/superpowers requesting-code-review",
-    "obra/superpowers writing-skills",
-    "obra/superpowers dispatching-parallel-agents",
-    "obra/superpowers receiving-code-review",
-    "obra/superpowers using-git-worktrees",
-    "obra/superpowers finishing-a-development-branch",
-    "wshobson/agents code-review-excellence",
-    "wshobson/agents api-design-principles",
-    "wshobson/agents architecture-patterns",
-    "wshobson/agents error-handling-patterns",
-    "wshobson/agents nodejs-backend-patterns",
-    "wshobson/agents microservices-patterns",
-    "wshobson/agents modern-javascript-patterns",
-    "wshobson/agents web-component-design",
-    "wshobson/agents async-python-patterns",
-    "wshobson/agents python-testing-patterns",
-    "boristane/agent-skills logging-best-practices"
-  ],
-  productivity: [
-    "softaworks/agent-toolkit daily-meeting-update",
-    "softaworks/agent-toolkit agent-md-refactor",
-    "softaworks/agent-toolkit session-handoff",
-    "softaworks/agent-toolkit meme-factory",
-    "softaworks/agent-toolkit qa-test-planner",
-    "softaworks/agent-toolkit writing-clearly-and-concisely",
-    "softaworks/agent-toolkit commit-work",
-    "softaworks/agent-toolkit mermaid-diagrams",
-    "softaworks/agent-toolkit dependency-updater",
-    "softaworks/agent-toolkit crafting-effective-readmes",
-    "softaworks/agent-toolkit reducing-entropy",
-    "softaworks/agent-toolkit feedback-mastery",
-    "softaworks/agent-toolkit marp-slide",
-    "softaworks/agent-toolkit professional-communication",
-    "softaworks/agent-toolkit difficult-workplace-conversations",
-    "anthropics/skills internal-comms",
-    "othmanadi/planning-with-files planning-with-files"
-  ],
-  security: [
-    "trailofbits/skills semgrep",
-    "trailofbits/skills secure-workflow-guide",
-    "trailofbits/skills codeql",
-    "trailofbits/skills property-based-testing",
-    "trailofbits/skills variant-analysis",
-    "trailofbits/skills guidelines-advisor",
-    "trailofbits/skills sharp-edges",
-    "trailofbits/skills differential-review",
-    "trailofbits/skills ask-questions-if-underspecified",
-    "squirrelscan/skills audit-website"
-  ],
-  mobile: [
-    "wshobson/agents mobile-ios-design",
-    "wshobson/agents mobile-android-design",
-    "dimillian/skills swiftui-ui-patterns",
-    "dimillian/skills swiftui-liquid-glass"
-  ],
-  obsidian: [
-    "kepano/obsidian-skills obsidian-markdown",
-    "kepano/obsidian-skills obsidian-bases",
-    "kepano/obsidian-skills json-canvas"
-  ],
-  prompts: [
-    "f/awesome-chatgpt-prompts skill-lookup",
-    "f/awesome-chatgpt-prompts prompt-lookup",
-    "wshobson/agents prompt-engineering-patterns"
-  ],
-  browser: [
-    "vercel-labs/agent-browser agent-browser"
-  ],
-  content: [
-    "op7418/humanizer-zh humanizer-zh",
-    "blader/humanizer humanizer",
-    "op7418/youtube-clipper-skill youtube-clipper",
-    "jimliu/baoyu-skills baoyu-slide-deck",
-    "jimliu/baoyu-skills baoyu-article-illustrator",
-    "jimliu/baoyu-skills baoyu-cover-image",
-    "jimliu/baoyu-skills baoyu-comic",
-    "jimliu/baoyu-skills baoyu-infographic",
-    "jimliu/baoyu-skills baoyu-image-gen"
-  ],
-  integrations: [
-    "intellectronica/agent-skills context7",
-    "softaworks/agent-toolkit gemini",
-    "softaworks/agent-toolkit codex"
-  ]
-};
-async function detectStack(projectDir) {
-  const stack = {
-    suggestedSkills: [],
-    suggestedAgents: ["security", "privacy", "bugs"],
-    dependencies: /* @__PURE__ */ new Set()
-  };
-  if (existsSync5(join4(projectDir, "tsconfig.json"))) {
-    stack.language = "TypeScript";
-    stack.suggestedAgents.push("typecheck");
-    stack.suggestedSkills.push("wshobson/agents typescript-advanced-types");
-  } else if (existsSync5(join4(projectDir, "package.json"))) {
-    stack.language = "JavaScript";
-  } else if (existsSync5(join4(projectDir, "requirements.txt")) || existsSync5(join4(projectDir, "pyproject.toml"))) {
-    stack.language = "Python";
-  } else if (existsSync5(join4(projectDir, "go.mod"))) {
-    stack.language = "Go";
-  } else if (existsSync5(join4(projectDir, "Cargo.toml"))) {
-    stack.language = "Rust";
-  }
-  if (existsSync5(join4(projectDir, "Package.swift")) || existsSync5(join4(projectDir, "project.pbxproj")) || existsSync5(join4(projectDir, "*.xcodeproj"))) {
-    stack.language = "Swift";
-    stack.suggestedSkills.push("dimillian/skills swiftui-ui-patterns");
-    stack.suggestedSkills.push("dimillian/skills swiftui-liquid-glass");
-  }
-  if (existsSync5(join4(projectDir, "pnpm-lock.yaml"))) {
-    stack.packageManager = "pnpm";
-  } else if (existsSync5(join4(projectDir, "yarn.lock"))) {
-    stack.packageManager = "yarn";
-  } else if (existsSync5(join4(projectDir, "bun.lockb"))) {
-    stack.packageManager = "bun";
-  } else if (existsSync5(join4(projectDir, "package-lock.json"))) {
-    stack.packageManager = "npm";
-  }
-  if (existsSync5(join4(projectDir, ".github", "workflows"))) {
-    stack.suggestedSkills.push("wshobson/agents github-actions-templates");
-  }
-  try {
-    const pkgPath = join4(projectDir, "package.json");
-    if (existsSync5(pkgPath)) {
-      const pkgContent = await readFile2(pkgPath, "utf-8");
-      const pkg = JSON.parse(pkgContent);
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      for (const dep of Object.keys(deps)) {
-        stack.dependencies.add(dep);
-      }
-      for (const dep of Object.keys(deps)) {
-        const skills = SKILL_MAPPINGS[dep];
-        if (skills) {
-          stack.suggestedSkills.push(...skills);
-        }
-      }
-      if (deps["next"]) {
-        stack.framework = `Next.js ${deps["next"].replace("^", "")}`;
-        stack.suggestedAgents.push("accessibility", "design");
-      } else if (deps["react"]) {
-        stack.framework = `React ${deps["react"].replace("^", "")}`;
-        stack.suggestedAgents.push("accessibility");
-      } else if (deps["vue"]) {
-        stack.framework = `Vue ${deps["vue"].replace("^", "")}`;
-      } else if (deps["nuxt"]) {
-        stack.framework = `Nuxt ${deps["nuxt"].replace("^", "")}`;
-      } else if (deps["svelte"]) {
-        stack.framework = "Svelte";
-      } else if (deps["express"]) {
-        stack.framework = "Express.js";
-      } else if (deps["fastify"]) {
-        stack.framework = "Fastify";
-      } else if (deps["hono"]) {
-        stack.framework = "Hono";
-      } else if (deps["elysia"]) {
-        stack.framework = "Elysia";
-      } else if (deps["@nestjs/core"]) {
-        stack.framework = "NestJS";
-      }
-      if (deps["next-auth"] || deps["@auth/core"]) {
-        stack.auth = "NextAuth.js";
-      } else if (deps["passport"]) {
-        stack.auth = "Passport.js";
-      } else if (deps["@clerk/nextjs"] || deps["@clerk/clerk-react"]) {
-        stack.auth = "Clerk";
-      } else if (deps["better-auth"]) {
-        stack.auth = "Better Auth";
-      }
-      if (deps["prisma"] || deps["@prisma/client"]) {
-        stack.database = "Prisma ORM";
-      } else if (deps["drizzle-orm"]) {
-        stack.database = "Drizzle ORM";
-      } else if (deps["@supabase/supabase-js"]) {
-        stack.database = "Supabase";
-      } else if (deps["mongoose"]) {
-        stack.database = "MongoDB (Mongoose)";
-      } else if (deps["pg"]) {
-        stack.database = "PostgreSQL";
-      } else if (deps["convex"]) {
-        stack.database = "Convex";
-      }
-      if (deps["stripe"] || deps["@stripe/stripe-js"]) {
-        stack.suggestedAgents.push("moneybags");
-      }
-    }
-  } catch {
-  }
-  if (!stack.database) {
-    if (existsSync5(join4(projectDir, "prisma", "schema.prisma"))) {
-      stack.database = "Prisma ORM";
-    } else if (existsSync5(join4(projectDir, "drizzle.config.ts"))) {
-      stack.database = "Drizzle ORM";
-    }
-  }
-  stack.suggestedSkills = [...new Set(stack.suggestedSkills)];
-  stack.suggestedAgents = [...new Set(stack.suggestedAgents)];
-  return stack;
-}
-function getSkillsByCategory(category) {
-  return SKILL_CATEGORIES[category] || [];
-}
-function getSkillCategories() {
-  return Object.entries(SKILL_CATEGORIES).map(([name, skills]) => ({
-    name,
-    count: skills.length
-  }));
-}
-
-// src/patterns/saved-patterns.ts
-import { createHash } from "crypto";
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join5, basename } from "path";
-async function loadSavedPatterns(workDir) {
-  const patternsPath = join5(getTrieDirectory(workDir), "saved-patterns.json");
-  try {
-    if (existsSync6(patternsPath)) {
-      const content = await readFile3(patternsPath, "utf-8");
-      return JSON.parse(content);
-    }
-  } catch {
-  }
-  return [];
-}
-async function savePatternsToProject(patterns, workDir) {
-  const { mkdir: mkdir2 } = await import("fs/promises");
-  const patternsPath = join5(getTrieDirectory(workDir), "saved-patterns.json");
-  await mkdir2(getTrieDirectory(workDir), { recursive: true });
-  await writeFile2(patternsPath, JSON.stringify(patterns, null, 2));
-}
-async function savePatternToProject(pattern, workDir) {
-  const patterns = await loadSavedPatterns(workDir);
-  const existing = patterns.findIndex((p) => p.id === pattern.id);
-  if (existing >= 0) {
-    patterns[existing] = {
-      ...patterns[existing],
-      ...pattern,
-      occurrences: patterns[existing].occurrences + 1
-    };
-  } else {
-    patterns.push(pattern);
-  }
-  await savePatternsToProject(patterns, workDir);
-}
-function detectPatternType(target, workDir) {
-  const scoutNames = [
-    "security",
-    "privacy",
-    "legal",
-    "accessibility",
-    "bug-finding",
-    "architecture",
-    "types",
-    "clean",
-    "devops",
-    "performance",
-    "ux",
-    "design",
-    "production-ready",
-    "agent-smith"
-  ];
-  if (scoutNames.includes(target.toLowerCase())) {
-    return "detection-rule";
-  }
-  const fullPath = join5(workDir, target);
-  if (existsSync6(fullPath) || target.includes("/") || target.includes("*") || target.endsWith(".ts") || target.endsWith(".js")) {
-    return "file-structure";
-  }
-  return "code-pattern";
-}
-function generatePatternId(target, type) {
-  const hash = createHash("sha256").update(`${type}:${target}`).digest("hex").slice(0, 12);
-  return `${type}-${hash}`;
-}
-function getDetectionRuleAgents(patterns) {
-  return patterns.filter((p) => p.type === "detection-rule").map((p) => p.detectionRule?.agent || p.name).filter(Boolean);
-}
-async function createSavedPattern(target, note, workDir) {
-  const projectName = basename(workDir);
-  const patternType = detectPatternType(target, workDir);
-  const savedPattern = {
-    id: generatePatternId(target, patternType),
-    type: patternType,
-    name: target,
-    description: note || `Pattern saved from ${projectName}`,
-    validated: false,
-    projects: [projectName],
-    occurrences: 1,
-    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    savedBy: projectName
-  };
-  if (patternType === "file-structure") {
-    savedPattern.filePatterns = [target];
-    savedPattern.architecture = {
-      structure: `Files matching ${target}`,
-      rationale: note || "File structure pattern that worked well"
-    };
-  } else if (patternType === "code-pattern") {
-    const issues = await searchIssues(target, { limit: 5 });
-    if (issues.length > 0) {
-      const latestIssue = issues[0];
-      savedPattern.codePattern = {
-        pattern: latestIssue?.issue.issue || target,
-        fix: latestIssue?.issue.fix || "Review and apply similar fix",
-        context: note || "Code pattern that worked well"
-      };
-    } else {
-      savedPattern.codePattern = {
-        pattern: target,
-        fix: "Review and apply similar fix",
-        context: note || "Code pattern that worked well"
-      };
-    }
-  } else if (patternType === "detection-rule") {
-    savedPattern.detectionRule = {
-      agent: target,
-      rule: `Detection rules from ${target} scout`,
-      severity: "moderate"
-    };
-  }
-  return savedPattern;
-}
-async function buildSavedPatternIssues(patterns, files, readFileContent) {
-  const issues = [];
-  for (const pattern of patterns) {
-    if (pattern.type === "detection-rule") continue;
-    const targetFiles = filterFilesForPattern(files, pattern);
-    if (targetFiles.length === 0) continue;
-    if (pattern.type === "file-structure") {
-      for (const file of targetFiles) {
-        issues.push(createPatternIssue(pattern, file, void 0));
-      }
-      continue;
-    }
-    if (pattern.type === "code-pattern" && pattern.codePattern) {
-      for (const file of targetFiles) {
-        const content = await readFileContent(file);
-        const match = findPatternMatch(content, pattern.codePattern.pattern);
-        if (match) {
-          issues.push(createPatternIssue(pattern, file, match.line));
-        }
-      }
-    }
-  }
-  return issues;
-}
-function filterFilesForPattern(files, pattern) {
-  if (pattern.type === "file-structure" && pattern.filePatterns) {
-    return files.filter((file) => pattern.filePatterns.some((p) => matchesFilePattern(file, p)));
-  }
-  if (pattern.type === "code-pattern") {
-    return files;
-  }
-  return [];
-}
-function matchesFilePattern(filePath, pattern) {
-  const normalized = filePath.replace(/\\/g, "/");
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLESTAR___").replace(/\*/g, "[^/]*").replace(/___DOUBLESTAR___/g, ".*");
-  const regex = new RegExp(`^${escaped}$`, "i");
-  return regex.test(normalized) || normalized.includes(pattern.replace(/\*+/g, ""));
-}
-function findPatternMatch(content, pattern) {
-  try {
-    const regex = new RegExp(pattern, "i");
-    const match = regex.exec(content);
-    if (!match || match.index === void 0) return null;
-    const line = getLineNumber(content, match.index);
-    return { line };
-  } catch {
-    const index = content.toLowerCase().indexOf(pattern.toLowerCase());
-    if (index === -1) return null;
-    const line = getLineNumber(content, index);
-    return { line };
-  }
-}
-function getLineNumber(content, index) {
-  return content.slice(0, index).split("\n").length;
-}
-function createPatternIssue(pattern, file, line) {
-  const description = pattern.description || `Saved pattern: ${pattern.name}`;
-  const fix = pattern.codePattern?.fix || "Apply the saved pattern from your other project.";
-  const issue = {
-    id: `saved-${pattern.id}-${hashFile(file)}`,
-    severity: "low",
-    issue: `Saved pattern suggestion: ${description}`,
-    fix,
-    file,
-    confidence: 0.6,
-    autoFixable: false,
-    agent: "saved-patterns",
-    category: "pattern-sharing"
-  };
-  if (line !== void 0) {
-    issue.line = line;
-  }
-  return issue;
-}
-function hashFile(file) {
-  return createHash("sha256").update(file).digest("hex").slice(0, 8);
-}
-
-export {
-  loadConfig,
-  saveConfig,
-  Triager,
-  Executor,
-  isTrieInitialized,
-  SKILL_CATEGORIES,
-  detectStack,
-  getSkillsByCategory,
-  getSkillCategories,
-  loadSavedPatterns,
-  savePatternsToProject,
-  savePatternToProject,
-  getDetectionRuleAgents,
-  createSavedPattern,
-  buildSavedPatternIssues
-};
-//# sourceMappingURL=chunk-CUXXRM3T.js.map