@triedotdev/mcp 1.0.110 → 1.0.112

package/dist/chunk-TKMV7JKN.js

@@ -0,0 +1,1562 @@
+import {
+  getTrieDirectory,
+  getWorkingDirectory
+} from "./chunk-R4AAPFXC.js";
+import {
+  isInteractiveMode
+} from "./chunk-APMV77PU.js";
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// src/utils/project-info.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+var PROJECT_MD_PATH = "PROJECT.md";
+function getProjectTemplate() {
+  return `# Project Information
+
+> This file stores important project context for AI assistants.
+> Edit freely - this file is yours, not auto-generated.
+> Available via MCP resource: \`trie://project\`
+
+---
+
+## Project Overview
+
+<!-- Describe your project's purpose and goals -->
+
+[Add project description here]
+
+---
+
+## Technology Stack
+
+<!-- List frameworks, languages, databases, cloud services, etc. -->
+
+- **Language:** 
+- **Framework:** 
+- **Database:** 
+- **Hosting:** 
+
+---
+
+## Architecture
+
+<!-- Key patterns, architectural decisions, and system design -->
+
+[Describe your architecture here]
+
+---
+
+## Coding Conventions
+
+<!-- Style guidelines, naming conventions, patterns to follow -->
+
+- 
+- 
+- 
+
+---
+
+## Environment
+
+<!-- URLs, API endpoints, deployment info -->
+
+| Environment | URL | Notes |
+|-------------|-----|-------|
+| Development | | |
+| Staging | | |
+| Production | | |
+
+---
+
+## Team
+
+<!-- Ownership, contacts, responsibilities -->
+
+- **Owner:** 
+- **Team:** 
+
+---
+
+## Compliance
+
+<!-- HIPAA, SOC2, GDPR, PCI-DSS requirements if applicable -->
+
+- [ ] GDPR
+- [ ] SOC2
+- [ ] HIPAA
+- [ ] PCI-DSS
+
+---
+
+## AI Instructions
+
+<!-- Special instructions for AI assistants working on this project -->
+
+When working on this project, AI assistants should:
+
+1. 
+2. 
+3. 
+
+---
+
+*This file is read by Trie agents and exposed via \`trie://project\` MCP resource.*
+*Edit this file to provide context to Claude Code, Cursor, GitHub Actions, and other AI tools.*
+`;
+}
+function projectInfoExists(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
+  return existsSync(projectPath);
+}
+async function loadProjectInfo(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
+  try {
+    if (!existsSync(projectPath)) {
+      return null;
+    }
+    return await readFile(projectPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function saveProjectInfo(content, workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const trieDir = getTrieDirectory(dir);
+  const projectPath = join(trieDir, PROJECT_MD_PATH);
+  await mkdir(trieDir, { recursive: true });
+  await writeFile(projectPath, content, "utf-8");
+}
+async function initProjectInfo(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
+  if (existsSync(projectPath)) {
+    return { created: false, path: projectPath };
+  }
+  await saveProjectInfo(getProjectTemplate(), dir);
+  return { created: true, path: projectPath };
+}
+async function getProjectSection(sectionName, workDir) {
+  const content = await loadProjectInfo(workDir);
+  if (!content) return null;
+  const sectionRegex = new RegExp(
+    `## ${escapeRegex(sectionName)}\\s*\\n([\\s\\S]*?)(?=\\n## |\\n---\\s*$|$)`,
+    "i"
+  );
+  const match = content.match(sectionRegex);
+  if (match?.[1]) {
+    return match[1].trim();
+  }
+  return null;
+}
+async function updateProjectSection(sectionName, newContent, workDir) {
+  let content = await loadProjectInfo(workDir);
+  if (!content) {
+    await initProjectInfo(workDir);
+    content = await loadProjectInfo(workDir);
+    if (!content) return false;
+  }
+  const sectionRegex = new RegExp(
+    `(## ${escapeRegex(sectionName)}\\s*\\n)([\\s\\S]*?)((?=\\n## )|(?=\\n---\\s*$)|$)`,
+    "i"
+  );
+  if (content.match(sectionRegex)) {
+    const updatedContent = content.replace(sectionRegex, `$1
+${newContent}
+
+$3`);
+    await saveProjectInfo(updatedContent, workDir);
+    return true;
+  }
+  return false;
+}
+async function appendToSection(sectionName, contentToAdd, workDir) {
+  const currentContent = await getProjectSection(sectionName, workDir);
+  if (currentContent === null) return false;
+  const newContent = currentContent + "\n" + contentToAdd;
+  return updateProjectSection(sectionName, newContent, workDir);
+}
+async function getProjectSections(workDir) {
+  const content = await loadProjectInfo(workDir);
+  if (!content) return [];
+  const sectionRegex = /^## (.+)$/gm;
+  const sections = [];
+  let match;
+  while ((match = sectionRegex.exec(content)) !== null) {
+    if (match[1]) {
+      sections.push(match[1].trim());
+    }
+  }
+  return sections;
+}
+async function getProjectInfoStructured(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(getTrieDirectory(dir), PROJECT_MD_PATH);
+  const content = await loadProjectInfo(dir);
+  if (!content) {
+    return {
+      exists: false,
+      path: projectPath,
+      sections: {},
+      raw: null
+    };
+  }
+  const sectionNames = await getProjectSections(dir);
+  const sections = {};
+  for (const name of sectionNames) {
+    const sectionContent = await getProjectSection(name, dir);
+    if (sectionContent) {
+      sections[name] = sectionContent;
+    }
+  }
+  return {
+    exists: true,
+    path: projectPath,
+    sections,
+    raw: content
+  };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/context-state.ts
+import { readFile as readFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, basename } from "path";
+var STATE_JSON_PATH = "state.json";
+async function loadContextState() {
+  const workDir = getWorkingDirectory(void 0, true);
+  const statePath = join2(getTrieDirectory(workDir), STATE_JSON_PATH);
+  const defaults = getDefaultState();
+  try {
+    if (existsSync2(statePath)) {
+      const content = await readFile2(statePath, "utf-8");
+      const loaded = JSON.parse(content);
+      return {
+        ...defaults,
+        ...loaded,
+        skills: loaded.skills || defaults.skills
+      };
+    }
+  } catch {
+  }
+  return defaults;
+}
+function getDefaultState() {
+  return {
+    lastScan: null,
+    healthScore: 0,
+    activePriorities: [
+      "Initial setup required - run first scan with `trie scan`",
+      "Configure agents in `.trie/config.json`",
+      "Set up CI/CD integration"
+    ],
+    contextSignals: {},
+    agentStatus: {},
+    scanHistory: [],
+    customAgents: [],
+    skills: {},
+    environment: detectEnvironment()
+  };
+}
+function detectEnvironment() {
+  if (process.env.GITHUB_ACTIONS) return "github-actions";
+  if (process.env.GITLAB_CI) return "gitlab-ci";
+  if (process.env.CI) return "ci";
+  const parent = process.env._ || "";
+  if (parent.includes("cursor")) return "cursor";
+  if (parent.includes("claude")) return "claude-code";
+  return "cli";
+}
+async function getContextForAI() {
+  const state = await loadContextState();
+  const workDir = getWorkingDirectory(void 0, true);
+  const lines = [];
+  if (projectInfoExists(workDir)) {
+    const projectInfo = await loadProjectInfo(workDir);
+    if (projectInfo) {
+      lines.push(projectInfo);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+  }
+  lines.push(
+    "## Trie Scan Context",
+    "",
+    `**Health Score:** ${state.healthScore}%`,
+    `**Last Scan:** ${state.lastScan ? new Date(state.lastScan.timestamp).toLocaleString() : "Never"}`,
+    "",
+    "**Active Priorities:**",
+    ...state.activePriorities.map((p) => `- ${p}`),
+    ""
+  );
+  if (state.lastScan) {
+    lines.push(
+      "**Recent Issues:**",
+      `- Critical: ${state.lastScan.issues.critical}`,
+      `- Serious: ${state.lastScan.issues.serious}`,
+      `- Moderate: ${state.lastScan.issues.moderate}`,
+      `- Low: ${state.lastScan.issues.low}`,
+      ""
+    );
+    if (state.lastScan.hotFiles.length > 0) {
+      lines.push(
+        "**Hot Files (most issues):**",
+        ...state.lastScan.hotFiles.slice(0, 5).map((f) => `- ${f.file}: ${f.issueCount} issues`),
+        ""
+      );
+    }
+  }
+  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 } 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 {
+          __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 = 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";
+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", "bugs"],
+    dependencies: /* @__PURE__ */ new Set()
+  };
+  if (existsSync5(join5(projectDir, "tsconfig.json"))) {
+    stack.language = "TypeScript";
+    stack.suggestedSkills.push("wshobson/agents typescript-advanced-types");
+  } else if (existsSync5(join5(projectDir, "package.json"))) {
+    stack.language = "JavaScript";
+  } else if (existsSync5(join5(projectDir, "requirements.txt")) || existsSync5(join5(projectDir, "pyproject.toml"))) {
+    stack.language = "Python";
+  } else if (existsSync5(join5(projectDir, "go.mod"))) {
+    stack.language = "Go";
+  } else if (existsSync5(join5(projectDir, "Cargo.toml"))) {
+    stack.language = "Rust";
+  }
+  if (existsSync5(join5(projectDir, "Package.swift")) || existsSync5(join5(projectDir, "project.pbxproj")) || existsSync5(join5(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"))) {
+    stack.packageManager = "pnpm";
+  } else if (existsSync5(join5(projectDir, "yarn.lock"))) {
+    stack.packageManager = "yarn";
+  } else if (existsSync5(join5(projectDir, "bun.lockb"))) {
+    stack.packageManager = "bun";
+  } else if (existsSync5(join5(projectDir, "package-lock.json"))) {
+    stack.packageManager = "npm";
+  }
+  if (existsSync5(join5(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 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";
+      }
+    }
+  } catch {
+  }
+  if (!stack.database) {
+    if (existsSync5(join5(projectDir, "prisma", "schema.prisma"))) {
+      stack.database = "Prisma ORM";
+    } else if (existsSync5(join5(projectDir, "drizzle.config.ts"))) {
+      stack.database = "Drizzle ORM";
+    }
+  }
+  stack.suggestedSkills = [...new Set(stack.suggestedSkills)];
+  stack.suggestedAgents = [...new Set(stack.suggestedAgents)];
+  return stack;
+}
+function getSkillCategories() {
+  return Object.entries(SKILL_CATEGORIES).map(([name, skills]) => ({
+    name,
+    count: skills.length
+  }));
+}
+
+// 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";
+var BOOTSTRAP_FILES = [
+  { name: "PROJECT.md", type: "user", description: "Project overview and conventions" },
+  { name: "RULES.md", type: "user", description: "Coding standards agents enforce" },
+  { name: "TEAM.md", type: "user", description: "Team ownership and escalation" },
+  { name: "BOOTSTRAP.md", type: "one-time", description: "First-run setup (deleted after)" },
+  { name: "AGENTS.md", type: "auto", description: "Auto-generated scan context" }
+];
+async function loadBootstrapContext(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const trieDir = getTrieDirectory(projectDir);
+  const files = [];
+  const contentParts = [];
+  let needsBootstrap2 = false;
+  for (const file of BOOTSTRAP_FILES) {
+    const filePath = join6(trieDir, file.name);
+    const exists = existsSync6(filePath);
+    if (file.name === "BOOTSTRAP.md" && exists) {
+      needsBootstrap2 = true;
+    }
+    let content;
+    if (exists) {
+      try {
+        content = await readFile5(filePath, "utf-8");
+        if (content.trim() && file.type !== "one-time") {
+          contentParts.push(`<!-- ${file.name} -->
+${content}`);
+        }
+      } catch {
+      }
+    }
+    const fileEntry = {
+      name: file.name,
+      path: filePath,
+      type: file.type,
+      exists
+    };
+    if (content) fileEntry.content = content;
+    files.push(fileEntry);
+  }
+  return {
+    files,
+    injectedContent: contentParts.join("\n\n---\n\n"),
+    needsBootstrap: needsBootstrap2
+  };
+}
+async function initializeBootstrapFiles(options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const trieDir = getTrieDirectory(projectDir);
+  await mkdir4(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);
+    if (exists && !options.force) {
+      skipped.push(file.name);
+      continue;
+    }
+    if (file.name === "BOOTSTRAP.md" && options.skipBootstrap) {
+      skipped.push(file.name);
+      continue;
+    }
+    if (file.name === "AGENTS.md") {
+      skipped.push(file.name);
+      continue;
+    }
+    const template = getFileTemplate(file.name, stack);
+    if (template) {
+      await writeFile3(filePath, template);
+      created.push(file.name);
+    }
+  }
+  return { created, skipped, stack };
+}
+async function completeBootstrap(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const bootstrapPath = join6(getTrieDirectory(projectDir), "BOOTSTRAP.md");
+  try {
+    await unlink(bootstrapPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function needsBootstrap(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const bootstrapPath = join6(getTrieDirectory(projectDir), "BOOTSTRAP.md");
+  return existsSync6(bootstrapPath);
+}
+async function loadRules(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const rulesPath = join6(getTrieDirectory(projectDir), "RULES.md");
+  try {
+    if (existsSync6(rulesPath)) {
+      return await readFile5(rulesPath, "utf-8");
+    }
+  } catch {
+  }
+  return null;
+}
+async function loadTeamInfo(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const teamPath = join6(getTrieDirectory(projectDir), "TEAM.md");
+  try {
+    if (existsSync6(teamPath)) {
+      return await readFile5(teamPath, "utf-8");
+    }
+  } catch {
+  }
+  return null;
+}
+function getFileTemplate(fileName, stack) {
+  switch (fileName) {
+    case "PROJECT.md":
+      return getProjectTemplate2(stack);
+    case "RULES.md":
+      return getRulesTemplate(stack);
+    case "TEAM.md":
+      return getTeamTemplate();
+    case "BOOTSTRAP.md":
+      return getBootstrapTemplate(stack);
+    default:
+      return null;
+  }
+}
+function getProjectTemplate2(stack) {
+  const lines = ["# Project Overview", "", "> Define your project context here. AI assistants read this first.", ""];
+  lines.push("## Description", "", "[Describe what this project does and who it's for]", "");
+  lines.push("## Technology Stack", "");
+  if (stack.framework) lines.push(`- **Framework:** ${stack.framework}`);
+  if (stack.language) lines.push(`- **Language:** ${stack.language}`);
+  if (stack.database) lines.push(`- **Database:** ${stack.database}`);
+  if (stack.auth) lines.push(`- **Auth:** ${stack.auth}`);
+  if (!stack.framework && !stack.language && !stack.database) {
+    lines.push("[Add your technology stack]");
+  }
+  lines.push("");
+  lines.push("## Architecture", "", "[Key patterns and design decisions]", "");
+  lines.push("## Coding Conventions", "", "[Style rules agents should follow]", "");
+  lines.push("## AI Instructions", "", "When working on this project:", "1. [Instruction 1]", "2. [Instruction 2]", "3. [Instruction 3]", "");
+  lines.push("---", "", "*Edit this file to provide project context to AI assistants.*");
+  return lines.join("\n");
+}
+function getRulesTemplate(stack) {
+  const packageManager = stack.packageManager || "npm";
+  return `# Project Rules
+
+> These rules are enforced by Trie agents during scans.
+> Violations appear as issues with [RULES] prefix.
+
+## Code Style
+
+1. Use named exports, not default exports
+2. Prefer \`${packageManager}\` for package management
+3. Maximum file length: 300 lines
+4. Use TypeScript strict mode
+
+## Testing Requirements
+
+1. Critical paths require unit tests
+2. API endpoints require integration tests
+3. Minimum coverage: 70%
+
+## Security Rules
+
+1. Never log sensitive data (passwords, tokens, PII)
+2. All API routes require authentication
+3. Rate limiting required on public endpoints
+4. SQL queries must use parameterized statements
+
+## Review Requirements
+
+1. All PRs require at least 1 reviewer
+2. Security-sensitive changes require security review
+3. Database migrations require review
+
+---
+
+*Edit this file to define your project's coding standards.*
+`;
+}
+function getTeamTemplate() {
+  return `# Team Structure
+
+## Code Ownership
+
+| Area | Owner | Backup | Review Required |
+|------|-------|--------|-----------------|
+| \`/src/api/\` | @backend-team | - | 1 approver |
+| \`/src/ui/\` | @frontend-team | - | 1 approver |
+| \`/src/auth/\` | @security-team | - | Security review |
+
+## Escalation
+
+| Severity | First Contact | Escalate To | SLA |
+|----------|--------------|-------------|-----|
+| Critical | Team lead | CTO | 1 hour |
+| Serious | PR reviewer | Team lead | 4 hours |
+| Moderate | Self-serve | - | 1 day |
+
+## Contacts
+
+- **Security:** [email/slack]
+- **Privacy:** [email/slack]
+- **Emergencies:** [phone/pager]
+
+---
+
+*Edit this file to define your team structure.*
+`;
+}
+function getBootstrapTemplate(stack) {
+  const skillCommands = stack.suggestedSkills.map((s) => `trie skills add ${s}`).join("\n");
+  const agentList = stack.suggestedAgents.join(", ");
+  const lines = [
+    "# Trie Bootstrap Checklist",
+    "",
+    "This file guides your first scan setup. **Delete when complete.**",
+    "",
+    "## Auto-Detected Stack",
+    "",
+    "Based on your project, Trie detected:"
+  ];
+  if (stack.framework) lines.push(`- **Framework:** ${stack.framework}`);
+  if (stack.language) lines.push(`- **Language:** ${stack.language}`);
+  if (stack.database) lines.push(`- **Database:** ${stack.database}`);
+  if (stack.auth) lines.push(`- **Auth:** ${stack.auth}`);
+  lines.push("", "## Recommended Actions", "", "### 1. Skills to Install", "Based on your stack, consider installing:", "```bash");
+  lines.push(skillCommands || "# No specific skills detected - browse https://skills.sh");
+  lines.push("```", "", "### 2. Agents to Enable", `Your stack suggests these agents: ${agentList || "security, bugs"}`, "");
+  lines.push("### 3. Configure Rules", "Add your coding standards to `.trie/RULES.md`.", "");
+  lines.push("### 4. Run First Scan", "```bash", "trie scan", "```", "");
+  lines.push("---", "", "**Delete this file after completing setup.** Run:", "```bash", "rm .trie/BOOTSTRAP.md", "```");
+  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,
+  getProjectSection,
+  updateProjectSection,
+  appendToSection,
+  getProjectSections,
+  getProjectInfoStructured,
+  getSkillCategories,
+  loadBootstrapContext,
+  initializeBootstrapFiles,
+  completeBootstrap,
+  needsBootstrap,
+  loadRules,
+  loadTeamInfo,
+  LinearIngester,
+  loadContextState,
+  getContextForAI
+};
+//# sourceMappingURL=chunk-TKMV7JKN.js.map