@triedotdev/mcp 1.0.41 → 1.0.42

package/dist/chunk-52SSNKXS.js

@@ -0,0 +1,814 @@
+import {
+  getWorkingDirectory
+} from "./chunk-IMFD4SJC.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 = ".trie/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(dir, PROJECT_MD_PATH);
+  return existsSync(projectPath);
+}
+async function loadProjectInfo(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(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 = join(dir, ".trie");
+  const projectPath = join(dir, 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(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) {
+    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) {
+    sections.push(match[1].trim());
+  }
+  return sections;
+}
+async function getProjectInfoStructured(workDir) {
+  const dir = workDir || getWorkingDirectory(void 0, true);
+  const projectPath = join(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/skills/installer.ts
+import { mkdir as mkdir2, rm, writeFile as writeFile2, readdir, readFile as readFile3, access, cp } from "fs/promises";
+import { join as join3 } from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/skills/parser.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function parseSkillMd(skillPath) {
+  const skillMdPath = join2(skillPath, "SKILL.md");
+  const rawContent = await readFile2(skillMdPath, "utf-8");
+  const frontmatterMatch = rawContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch || !frontmatterMatch[1]) {
+    throw new Error("Invalid SKILL.md: missing YAML frontmatter");
+  }
+  const frontmatter = parseYamlFrontmatter(frontmatterMatch[1]);
+  if (!frontmatter.name || !frontmatter.description) {
+    throw new Error("Invalid SKILL.md: missing required name or description in frontmatter");
+  }
+  const content = rawContent.slice(frontmatterMatch[0].length).trim();
+  return {
+    frontmatter,
+    content,
+    rawContent
+  };
+}
+function parseYamlFrontmatter(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    if (value === "") continue;
+    if (typeof value === "string") {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+        value = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      }
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/skills/installer.ts
+var execAsync = promisify(exec);
+async function installSkill(source, skillName) {
+  const parts = source.split("/");
+  if (parts.length < 2) {
+    return { success: false, name: "unknown", error: "Invalid source format. Use owner/repo or owner/repo/skill-name" };
+  }
+  const owner = parts[0];
+  const repo = parts[1];
+  const specifiedSkill = skillName || parts[2];
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const tempDir = join3(skillsDir, `.temp-${Date.now()}`);
+  try {
+    await mkdir2(skillsDir, { recursive: true });
+    const repoUrl = `https://github.com/${owner}/${repo}.git`;
+    await execAsync(`git clone --depth 1 "${repoUrl}" "${tempDir}"`, { timeout: 6e4 });
+    const sourcePath = await findSkillPath(tempDir, specifiedSkill);
+    if (!sourcePath) {
+      throw new Error(`SKILL.md not found in repository. Searched in: root, skills/, ${specifiedSkill || "subdirectories"}`);
+    }
+    const parsed = await parseSkillMd(sourcePath);
+    const name = parsed.frontmatter.name;
+    const targetPath = join3(skillsDir, name);
+    await rm(targetPath, { recursive: true, force: true });
+    await cp(sourcePath, targetPath, { recursive: true });
+    await writeFile2(join3(targetPath, ".installed.json"), JSON.stringify({
+      installedFrom: source,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      repository: `${owner}/${repo}`
+    }, null, 2));
+    return { success: true, name, path: targetPath };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, name: skillName || "unknown", error: message };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function findSkillPath(repoPath, skillName) {
+  const searchPaths = [];
+  if (skillName) {
+    searchPaths.push(
+      join3(repoPath, "skills", skillName),
+      join3(repoPath, skillName)
+    );
+  }
+  searchPaths.push(
+    repoPath,
+    join3(repoPath, "skill")
+  );
+  if (!skillName) {
+    try {
+      const skillsSubdir = join3(repoPath, "skills");
+      await access(skillsSubdir);
+      const entries = await readdir(skillsSubdir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          searchPaths.push(join3(skillsSubdir, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  for (const searchPath of searchPaths) {
+    try {
+      await parseSkillMd(searchPath);
+      return searchPath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function listInstalledSkills() {
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const skills = [];
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const skillPath = join3(skillsDir, entry.name);
+      try {
+        const parsed = await parseSkillMd(skillPath);
+        const metaPath = join3(skillPath, ".installed.json");
+        let meta = { installedFrom: "unknown", installedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        try {
+          meta = JSON.parse(await readFile3(metaPath, "utf-8"));
+        } catch {
+        }
+        skills.push({
+          name: parsed.frontmatter.name,
+          description: parsed.frontmatter.description,
+          path: skillPath,
+          installedFrom: meta.installedFrom,
+          installedAt: meta.installedAt
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+async function removeSkill(skillName) {
+  const skillsDir = join3(getWorkingDirectory(void 0, true), ".trie", "skills");
+  const skillPath = join3(skillsDir, skillName);
+  try {
+    await rm(skillPath, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/context-state.ts
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+var AGENTS_MD_PATH = ".trie/AGENTS.md";
+var STATE_JSON_PATH = ".trie/state.json";
+async function loadContextState() {
+  const workDir = getWorkingDirectory(void 0, true);
+  const statePath = join4(workDir, STATE_JSON_PATH);
+  const defaults = getDefaultState();
+  try {
+    if (existsSync2(statePath)) {
+      const content = await readFile4(statePath, "utf-8");
+      const loaded = JSON.parse(content);
+      return {
+        ...defaults,
+        ...loaded,
+        skills: loaded.skills || defaults.skills
+      };
+    }
+  } catch {
+  }
+  return defaults;
+}
+async function saveContextState(state) {
+  const workDir = getWorkingDirectory(void 0, true);
+  const trieDir = join4(workDir, ".trie");
+  const statePath = join4(workDir, STATE_JSON_PATH);
+  await mkdir3(trieDir, { recursive: true });
+  await writeFile3(statePath, JSON.stringify(state, null, 2));
+}
+async function updateContextAfterScan(results, filesScanned, contextSignals, duration) {
+  const state = await loadContextState();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const allIssues = results.flatMap((r) => r.issues);
+  const issueCounts = {
+    critical: allIssues.filter((i) => i.severity === "critical").length,
+    serious: allIssues.filter((i) => i.severity === "serious").length,
+    moderate: allIssues.filter((i) => i.severity === "moderate").length,
+    low: allIssues.filter((i) => i.severity === "low").length,
+    total: allIssues.length
+  };
+  const fileIssueMap = /* @__PURE__ */ new Map();
+  for (const issue of allIssues) {
+    const count = fileIssueMap.get(issue.file) || 0;
+    fileIssueMap.set(issue.file, count + 1);
+  }
+  const hotFiles = Array.from(fileIssueMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([file, issueCount]) => ({ file, issueCount }));
+  const scanSummary = {
+    timestamp: now,
+    agents: results.map((r) => r.agent),
+    filesScanned,
+    issues: issueCounts,
+    duration,
+    hotFiles
+  };
+  for (const result of results) {
+    state.agentStatus[result.agent] = {
+      lastRun: now,
+      issuesFound: result.issues.length
+    };
+  }
+  const criticalPenalty = issueCounts.critical * 25;
+  const seriousPenalty = issueCounts.serious * 10;
+  const moderatePenalty = issueCounts.moderate * 3;
+  const lowPenalty = issueCounts.low * 1;
+  const totalPenalty = Math.min(100, criticalPenalty + seriousPenalty + moderatePenalty + lowPenalty);
+  state.healthScore = Math.max(0, 100 - totalPenalty);
+  state.activePriorities = generatePriorities(issueCounts, contextSignals);
+  state.contextSignals = { ...state.contextSignals, ...contextSignals };
+  state.scanHistory = [scanSummary, ...state.scanHistory.slice(0, 19)];
+  state.lastScan = scanSummary;
+  await saveContextState(state);
+  await updateAgentsMd(state);
+}
+async function updateAgentsMd(state) {
+  const workDir = getWorkingDirectory(void 0, true);
+  const mdPath = join4(workDir, AGENTS_MD_PATH);
+  let content;
+  try {
+    content = await readFile4(mdPath, "utf-8");
+  } catch {
+    content = getAgentsMdTemplate();
+  }
+  content = updateSection(content, "Project State", generateProjectStateTable(state));
+  content = updateSection(content, "Active Priorities", generatePrioritiesList(state));
+  content = updateSection(content, "Agent Status", generateAgentStatusTable(state));
+  content = updateSection(content, "Recent Scan History", generateScanHistoryTable(state));
+  content = updateSection(content, "Context Signals Detected", generateContextSignals(state));
+  content = updateSection(content, "Risk Assessment", generateRiskAssessment(state));
+  content = updateSection(content, "Hot Files", generateHotFilesSection(state));
+  content = content.replace(
+    /Last updated:.*$/m,
+    `Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+  );
+  await writeFile3(mdPath, content);
+}
+function updateSection(content, sectionName, newContent) {
+  const sectionRegex = new RegExp(
+    `(### ${sectionName}[\\s\\S]*?)(?=###|---|
+## |$)`,
+    "g"
+  );
+  const replacement = `### ${sectionName}
+${newContent}
+
+`;
+  if (content.match(sectionRegex)) {
+    return content.replace(sectionRegex, replacement);
+  }
+  return content;
+}
+function generateProjectStateTable(state) {
+  const lastScan = state.lastScan;
+  const lastScanDate = lastScan ? new Date(lastScan.timestamp).toLocaleString() : "Never";
+  const criticalCount = lastScan?.issues.critical ?? 0;
+  const totalTasks = lastScan?.issues.total ?? 0;
+  return `| Metric | Value | Updated |
+|--------|-------|---------|
+| Last Scan | ${lastScanDate} | ${lastScan ? "Auto" : "-"} |
+| Critical Issues | ${criticalCount} | ${lastScan ? "Auto" : "-"} |
+| Open Tasks | ${totalTasks} | ${lastScan ? "Auto" : "-"} |
+| Health Score | ${state.healthScore}% | ${lastScan ? "Auto" : "-"} |`;
+}
+function generatePrioritiesList(state) {
+  if (state.activePriorities.length === 0) {
+    return "_No active priorities. Run a scan to identify issues._";
+  }
+  return state.activePriorities.map((p, i) => `${i + 1}. ${p}`).join("\n");
+}
+function generatePriorities(issues, contextSignals) {
+  const priorities = [];
+  if (issues.critical > 0) {
+    priorities.push(`\u{1F6A8} Fix ${issues.critical} critical security issue${issues.critical > 1 ? "s" : ""} immediately`);
+  }
+  if (issues.serious > 0) {
+    priorities.push(`\u26A0\uFE0F Address ${issues.serious} serious issue${issues.serious > 1 ? "s" : ""} before deployment`);
+  }
+  if (contextSignals.touchesAuth && issues.critical === 0) {
+    priorities.push("\u2705 Auth code reviewed - continue monitoring");
+  }
+  if (contextSignals.touchesPayments) {
+    priorities.push("\u{1F4B3} Payment code detected - ensure PCI compliance");
+  }
+  if (contextSignals.touchesUserData) {
+    priorities.push("\u{1F510} User data handling detected - verify privacy compliance");
+  }
+  if (issues.moderate > 5) {
+    priorities.push(`\u{1F4CB} Schedule time to address ${issues.moderate} moderate issues`);
+  }
+  if (priorities.length === 0) {
+    priorities.push("\u2728 No critical issues - focus on feature development");
+  }
+  return priorities.slice(0, 5);
+}
+function generateAgentStatusTable(state) {
+  const builtInAgents = [
+    "security",
+    "privacy",
+    "legal",
+    "accessibility",
+    "bugs",
+    "design",
+    "architecture",
+    "performance",
+    "devops",
+    "soc2",
+    "e2e",
+    "typecheck",
+    "visual-qa",
+    "data-flow"
+  ];
+  let table = `| Agent | Status | Last Run | Issues Found |
+|-------|--------|----------|--------------|`;
+  for (const agent of builtInAgents) {
+    const status = state.agentStatus[agent];
+    const lastRun = status?.lastRun ? new Date(status.lastRun).toLocaleDateString() : "Never";
+    const issues = status?.issuesFound ?? "-";
+    const statusEmoji = status ? "\u2705" : "\u23F8\uFE0F";
+    table += `
+| ${agent} | ${statusEmoji} Ready | ${lastRun} | ${issues} |`;
+  }
+  return table;
+}
+function generateScanHistoryTable(state) {
+  if (state.scanHistory.length === 0) {
+    return `| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|
+| - | - | - | - | - |`;
+  }
+  let table = `| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|`;
+  for (const scan of state.scanHistory.slice(0, 10)) {
+    const date = new Date(scan.timestamp).toLocaleDateString();
+    const agents = scan.agents.slice(0, 3).join(", ") + (scan.agents.length > 3 ? "..." : "");
+    const duration = `${(scan.duration / 1e3).toFixed(1)}s`;
+    table += `
+| ${date} | ${agents} | ${scan.filesScanned} | ${scan.issues.total} | ${duration} |`;
+  }
+  return table;
+}
+function generateContextSignals(state) {
+  const signals = [
+    "touchesAuth",
+    "touchesPayments",
+    "touchesUserData",
+    "touchesAPI",
+    "touchesDatabase",
+    "touchesCrypto"
+  ];
+  return signals.map((s) => {
+    const value = state.contextSignals[s];
+    const emoji = value === true ? "\u2705" : value === false ? "\u274C" : "\u2753";
+    return `- \`${s}\`: ${emoji} ${value === void 0 ? "Unknown" : value ? "Yes" : "No"}`;
+  }).join("\n");
+}
+function generateRiskAssessment(state) {
+  const score = state.healthScore;
+  let riskLevel;
+  let confidence;
+  if (state.lastScan === null) {
+    return `- Overall Risk: Unknown
+- Confidence: 0%`;
+  }
+  if (score >= 90) {
+    riskLevel = "\u{1F7E2} Low";
+    confidence = 95;
+  } else if (score >= 70) {
+    riskLevel = "\u{1F7E1} Medium";
+    confidence = 85;
+  } else if (score >= 50) {
+    riskLevel = "\u{1F7E0} High";
+    confidence = 80;
+  } else {
+    riskLevel = "\u{1F534} Critical";
+    confidence = 90;
+  }
+  return `- Overall Risk: ${riskLevel}
+- Health Score: ${score}%
+- Confidence: ${confidence}%`;
+}
+function generateHotFilesSection(state) {
+  if (!state.lastScan || state.lastScan.hotFiles.length === 0) {
+    return "_Run a scan to identify hot files._";
+  }
+  return state.lastScan.hotFiles.map((f) => `- \`${f.file}\` - ${f.issueCount} issue${f.issueCount > 1 ? "s" : ""}`).join("\n");
+}
+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 recordSkillInstalled(params) {
+  const state = await loadContextState();
+  state.skills[params.name] = {
+    source: params.source,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    timesApplied: 0,
+    appliedBy: []
+  };
+  await saveContextState(state);
+}
+async function recordSkillUsage(params) {
+  const state = await loadContextState();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const skillName of params.skillNames) {
+    const skillRecord = state.skills[skillName];
+    if (skillRecord) {
+      skillRecord.timesApplied++;
+      skillRecord.lastApplied = now;
+      if (!skillRecord.appliedBy.includes(params.agentName)) {
+        skillRecord.appliedBy.push(params.agentName);
+      }
+    }
+  }
+  const agentStatus = state.agentStatus[params.agentName];
+  if (agentStatus) {
+    agentStatus.skillsApplied = params.skillNames;
+  }
+  await saveContextState(state);
+}
+function getAgentsMdTemplate() {
+  return `# Trie Agent Context
+
+> **Auto-generated file** - Updated automatically when agents run.
+> Last updated: Never (initial state)
+
+This file provides prioritized context for all AI coding assistants working with this codebase.
+Agents should read this file first and update it after completing scans.
+
+---
+
+## Quick Context (Read First)
+
+### Project State
+| Metric | Value | Updated |
+|--------|-------|---------|
+| Last Scan | Never | - |
+| Critical Issues | 0 | - |
+| Open Tasks | 0 | - |
+| Health Score | Unknown | - |
+
+### Active Priorities
+1. Initial setup required - run first scan with \`trie scan\`
+2. Configure agents in \`.trie/config.json\`
+3. Set up CI/CD integration
+
+### Hot Files
+_Run a scan to identify hot files._
+
+---
+
+## Agent Status
+
+### Agent Status
+| Agent | Status | Last Run | Issues Found |
+|-------|--------|----------|--------------|
+| security | Ready | Never | - |
+| privacy | Ready | Never | - |
+| bugs | Ready | Never | - |
+
+### Recent Scan History
+| Date | Agents | Files | Issues | Duration |
+|------|--------|-------|--------|----------|
+| - | - | - | - | - |
+
+---
+
+## Context Analysis
+
+### Context Signals Detected
+- \`touchesAuth\`: Unknown
+- \`touchesPayments\`: Unknown
+- \`touchesUserData\`: Unknown
+- \`touchesAPI\`: Unknown
+- \`touchesDatabase\`: Unknown
+- \`touchesCrypto\`: Unknown
+
+### Risk Assessment
+- Overall Risk: Unknown
+- Confidence: 0%
+
+---
+
+*This file is maintained by Trie agents. Manual edits will be preserved in non-auto sections.*
+`;
+}
+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");
+}
+
+export {
+  parseSkillMd,
+  installSkill,
+  listInstalledSkills,
+  removeSkill,
+  projectInfoExists,
+  loadProjectInfo,
+  initProjectInfo,
+  getProjectSection,
+  updateProjectSection,
+  appendToSection,
+  getProjectSections,
+  getProjectInfoStructured,
+  loadContextState,
+  updateContextAfterScan,
+  recordSkillInstalled,
+  recordSkillUsage,
+  getContextForAI
+};
+//# sourceMappingURL=chunk-52SSNKXS.js.map