@triedotdev/mcp 1.0.138 → 1.0.140

package/dist/{chunk-D3AS5LY7.js → chunk-7OJ6JIPL.js}

@@ -2,9 +2,6 @@ import {
   getTrieDirectory,
   getWorkingDirectory
 } from "./chunk-SH7H3WRU.js";
-import {
-  isInteractiveMode
-} from "./chunk-APMV77PU.js";
 
 // src/utils/project-info.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
@@ -313,449 +310,10 @@ async function getContextForAI() {
   return lines.join("\n");
 }
 
-// src/config/loader.ts
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4, dirname } from "path";
-
-// src/config/validation.ts
-import { z } from "zod";
-import { existsSync as existsSync3, readFileSync, mkdirSync } from "fs";
-import { resolve, join as join3 } 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 = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-        if (existsSync3(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 (!existsSync3(resolvedPath)) {
-          errors.push(`Include path does not exist: ${path}`);
-        }
-      }
-    }
-    if (paths?.configDir) {
-      const configPath = resolve(paths.configDir);
-      if (!existsSync3(configPath)) {
-        try {
-          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 = join3(workDir, envFile);
-          if (existsSync3(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 = join4(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-  try {
-    if (!existsSync4(configPath)) {
-      return DEFAULT_CONFIG;
-    }
-    const configFile = await readFile3(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 = join4(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
-  const dir = dirname(configPath);
-  if (!existsSync4(dir)) {
-    await mkdir3(dir, { recursive: true });
-  }
-  await writeFile2(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/bootstrap/stack-detector.ts
-import { readFile as readFile4 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 var SKILL_MAPPINGS = {
   // Frontend Frameworks - React/Next.js
   "next": [
@@ -1062,39 +620,39 @@ async function detectStack(projectDir) {
     suggestedAgents: ["security", "bugs"],
     dependencies: /* @__PURE__ */ new Set()
   };
-  if (existsSync5(join5(projectDir, "tsconfig.json"))) {
+  if (existsSync3(join3(projectDir, "tsconfig.json"))) {
     stack.language = "TypeScript";
     stack.suggestedSkills.push("wshobson/agents typescript-advanced-types");
-  } else if (existsSync5(join5(projectDir, "package.json"))) {
+  } else if (existsSync3(join3(projectDir, "package.json"))) {
     stack.language = "JavaScript";
-  } else if (existsSync5(join5(projectDir, "requirements.txt")) || existsSync5(join5(projectDir, "pyproject.toml"))) {
+  } else if (existsSync3(join3(projectDir, "requirements.txt")) || existsSync3(join3(projectDir, "pyproject.toml"))) {
     stack.language = "Python";
-  } else if (existsSync5(join5(projectDir, "go.mod"))) {
+  } else if (existsSync3(join3(projectDir, "go.mod"))) {
     stack.language = "Go";
-  } else if (existsSync5(join5(projectDir, "Cargo.toml"))) {
+  } else if (existsSync3(join3(projectDir, "Cargo.toml"))) {
     stack.language = "Rust";
   }
-  if (existsSync5(join5(projectDir, "Package.swift")) || existsSync5(join5(projectDir, "project.pbxproj")) || existsSync5(join5(projectDir, "*.xcodeproj"))) {
+  if (existsSync3(join3(projectDir, "Package.swift")) || existsSync3(join3(projectDir, "project.pbxproj")) || existsSync3(join3(projectDir, "*.xcodeproj"))) {
     stack.language = "Swift";
     stack.suggestedSkills.push("dimillian/skills swiftui-ui-patterns");
     stack.suggestedSkills.push("dimillian/skills swiftui-liquid-glass");
   }
-  if (existsSync5(join5(projectDir, "pnpm-lock.yaml"))) {
+  if (existsSync3(join3(projectDir, "pnpm-lock.yaml"))) {
     stack.packageManager = "pnpm";
-  } else if (existsSync5(join5(projectDir, "yarn.lock"))) {
+  } else if (existsSync3(join3(projectDir, "yarn.lock"))) {
     stack.packageManager = "yarn";
-  } else if (existsSync5(join5(projectDir, "bun.lockb"))) {
+  } else if (existsSync3(join3(projectDir, "bun.lockb"))) {
     stack.packageManager = "bun";
-  } else if (existsSync5(join5(projectDir, "package-lock.json"))) {
+  } else if (existsSync3(join3(projectDir, "package-lock.json"))) {
     stack.packageManager = "npm";
   }
-  if (existsSync5(join5(projectDir, ".github", "workflows"))) {
+  if (existsSync3(join3(projectDir, ".github", "workflows"))) {
     stack.suggestedSkills.push("wshobson/agents github-actions-templates");
   }
   try {
-    const pkgPath = join5(projectDir, "package.json");
-    if (existsSync5(pkgPath)) {
-      const pkgContent = await readFile4(pkgPath, "utf-8");
+    const pkgPath = join3(projectDir, "package.json");
+    if (existsSync3(pkgPath)) {
+      const pkgContent = await readFile3(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgContent);
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       for (const dep of Object.keys(deps)) {
@@ -1155,9 +713,9 @@ async function detectStack(projectDir) {
   } catch {
   }
   if (!stack.database) {
-    if (existsSync5(join5(projectDir, "prisma", "schema.prisma"))) {
+    if (existsSync3(join3(projectDir, "prisma", "schema.prisma"))) {
       stack.database = "Prisma ORM";
-    } else if (existsSync5(join5(projectDir, "drizzle.config.ts"))) {
+    } else if (existsSync3(join3(projectDir, "drizzle.config.ts"))) {
       stack.database = "Drizzle ORM";
     }
   }
@@ -1173,9 +731,9 @@ function getSkillCategories() {
 }
 
 // src/bootstrap/files.ts
-import { readFile as readFile5, writeFile as writeFile3, unlink, mkdir as mkdir4 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { readFile as readFile4, writeFile as writeFile2, unlink, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 var BOOTSTRAP_FILES = [
   { name: "PROJECT.md", type: "user", description: "Project overview and conventions" },
   { name: "RULES.md", type: "user", description: "Coding standards agents enforce" },
@@ -1190,15 +748,15 @@ async function loadBootstrapContext(workDir) {
   const contentParts = [];
   let needsBootstrap2 = false;
   for (const file of BOOTSTRAP_FILES) {
-    const filePath = join6(trieDir, file.name);
-    const exists = existsSync6(filePath);
+    const filePath = join4(trieDir, file.name);
+    const exists = existsSync4(filePath);
     if (file.name === "BOOTSTRAP.md" && exists) {
       needsBootstrap2 = true;
     }
     let content;
     if (exists) {
       try {
-        content = await readFile5(filePath, "utf-8");
+        content = await readFile4(filePath, "utf-8");
         if (content.trim() && file.type !== "one-time") {
           contentParts.push(`<!-- ${file.name} -->
 ${content}`);
@@ -1224,13 +782,13 @@ ${content}`);
 async function initializeBootstrapFiles(options = {}) {
   const projectDir = options.workDir || getWorkingDirectory(void 0, true);
   const trieDir = getTrieDirectory(projectDir);
-  await mkdir4(trieDir, { recursive: true });
+  await mkdir3(trieDir, { recursive: true });
   const created = [];
   const skipped = [];
   const stack = await detectStack(projectDir);
   for (const file of BOOTSTRAP_FILES) {
-    const filePath = join6(trieDir, file.name);
-    const exists = existsSync6(filePath);
+    const filePath = join4(trieDir, file.name);
+    const exists = existsSync4(filePath);
     if (exists && !options.force) {
       skipped.push(file.name);
       continue;
@@ -1245,7 +803,7 @@ async function initializeBootstrapFiles(options = {}) {
     }
     const template = getFileTemplate(file.name, stack);
     if (template) {
-      await writeFile3(filePath, template);
+      await writeFile2(filePath, template);
       created.push(file.name);
     }
   }
@@ -1253,7 +811,7 @@ async function initializeBootstrapFiles(options = {}) {
 }
 async function completeBootstrap(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const bootstrapPath = join6(getTrieDirectory(projectDir), "BOOTSTRAP.md");
+  const bootstrapPath = join4(getTrieDirectory(projectDir), "BOOTSTRAP.md");
   try {
     await unlink(bootstrapPath);
     return true;
@@ -1263,15 +821,15 @@ async function completeBootstrap(workDir) {
 }
 function needsBootstrap(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const bootstrapPath = join6(getTrieDirectory(projectDir), "BOOTSTRAP.md");
-  return existsSync6(bootstrapPath);
+  const bootstrapPath = join4(getTrieDirectory(projectDir), "BOOTSTRAP.md");
+  return existsSync4(bootstrapPath);
 }
 async function loadRules(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const rulesPath = join6(getTrieDirectory(projectDir), "RULES.md");
+  const rulesPath = join4(getTrieDirectory(projectDir), "RULES.md");
   try {
-    if (existsSync6(rulesPath)) {
-      return await readFile5(rulesPath, "utf-8");
+    if (existsSync4(rulesPath)) {
+      return await readFile4(rulesPath, "utf-8");
     }
   } catch {
   }
@@ -1279,10 +837,10 @@ async function loadRules(workDir) {
 }
 async function loadTeamInfo(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const teamPath = join6(getTrieDirectory(projectDir), "TEAM.md");
+  const teamPath = join4(getTrieDirectory(projectDir), "TEAM.md");
   try {
-    if (existsSync6(teamPath)) {
-      return await readFile5(teamPath, "utf-8");
+    if (existsSync4(teamPath)) {
+      return await readFile4(teamPath, "utf-8");
     }
   } catch {
   }
@@ -1413,129 +971,7 @@ function getBootstrapTemplate(stack) {
   return lines.join("\n");
 }
 
-// src/ingest/linear-ingester.ts
-var LinearIngester = class {
-  graph;
-  constructor(_projectPath, graph) {
-    this.graph = graph;
-  }
-  async syncTickets() {
-    const apiKey = await this.getApiKey();
-    if (!apiKey) {
-      console.warn('Linear API key not found. Run "trie linear auth <key>" to enable ticket sync.');
-      return;
-    }
-    const tickets = await this.fetchActiveTickets(apiKey);
-    for (const ticket of tickets) {
-      await this.ingestTicket(ticket);
-    }
-  }
-  async getApiKey() {
-    const config = await loadConfig();
-    return config.apiKeys?.linear || process.env.LINEAR_API_KEY || null;
-  }
-  async fetchActiveTickets(apiKey) {
-    const query = `
-      query {
-        issues(filter: { state: { type: { in: ["started", "unstarted"] } } }) {
-          nodes {
-            id
-            identifier
-            title
-            description
-            priority
-            status {
-              name
-            }
-            assignee {
-              name
-            }
-            labels {
-              nodes {
-                name
-              }
-            }
-            createdAt
-            updatedAt
-          }
-        }
-      }
-    `;
-    const response = await fetch("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": apiKey
-      },
-      body: JSON.stringify({ query })
-    });
-    if (!response.ok) {
-      throw new Error(`Linear API error: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return data.data.issues.nodes;
-  }
-  async ingestTicket(ticket) {
-    const labels = ticket.labels.nodes.map((l) => l.name);
-    const intentVibe = this.extractIntentVibes(ticket.title, ticket.description, labels);
-    const linkedFiles = this.extractLinkedFiles(ticket.description);
-    const data = {
-      ticketId: ticket.identifier,
-      title: ticket.title,
-      description: ticket.description || "",
-      priority: this.mapPriority(ticket.priority),
-      labels,
-      intentVibe,
-      linkedFiles,
-      status: ticket.status.name,
-      assignee: ticket.assignee?.name || null,
-      createdAt: ticket.createdAt,
-      updatedAt: ticket.updatedAt
-    };
-    await this.graph.addNode("linear-ticket", data);
-    for (const file of linkedFiles) {
-      const fileNode = await this.graph.getNode("file", file);
-      if (fileNode) {
-        await this.graph.addEdge(`linear:${ticket.identifier}`, fileNode.id, "relatedTo");
-      }
-    }
-  }
-  extractIntentVibes(title, description, labels) {
-    const vibes = /* @__PURE__ */ new Set();
-    const text = (title + " " + (description || "") + " " + labels.join(" ")).toLowerCase();
-    if (text.includes("performance") || text.includes("slow") || text.includes("optimize")) vibes.add("performance");
-    if (text.includes("security") || text.includes("auth") || text.includes("vulnerability")) vibes.add("security");
-    if (text.includes("refactor") || text.includes("cleanup") || text.includes("debt")) vibes.add("refactor");
-    if (text.includes("feature") || text.includes("new")) vibes.add("feature");
-    if (text.includes("bug") || text.includes("fix") || text.includes("broken")) vibes.add("bug");
-    if (text.includes("breaking") || text.includes("major change")) vibes.add("breaking-change");
-    return Array.from(vibes);
-  }
-  extractLinkedFiles(description) {
-    if (!description) return [];
-    const matches = description.match(/[\\w./_-]+\\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs)/gi);
-    if (!matches) return [];
-    return Array.from(new Set(matches.map((m) => m.replace(/^\.\/+/, ""))));
-  }
-  mapPriority(priority) {
-    switch (priority) {
-      case 1:
-        return "urgent";
-      case 2:
-        return "high";
-      case 3:
-        return "medium";
-      case 4:
-        return "low";
-      default:
-        return "none";
-    }
-  }
-};
-
 export {
-  loadConfig,
-  saveConfig,
   projectInfoExists,
   loadProjectInfo,
   initProjectInfo,
@@ -1551,8 +987,7 @@ export {
   needsBootstrap,
   loadRules,
   loadTeamInfo,
-  LinearIngester,
   loadContextState,
   getContextForAI
 };
-//# sourceMappingURL=chunk-D3AS5LY7.js.map
+//# sourceMappingURL=chunk-7OJ6JIPL.js.map