@triedotdev/mcp 1.0.94 → 1.0.99

package/dist/cli/create-agent.js

@@ -1,14 +1,938 @@
 #!/usr/bin/env node
 import {
-  buildAgentFromDocument
-} from "../chunk-OWBWNXSC.js";
-import "../chunk-WT3XQCG2.js";
-import "../chunk-JAAIHNOE.js";
+  getTrieDirectory,
+  getWorkingDirectory
+} from "../chunk-R4AAPFXC.js";
+import "../chunk-APMV77PU.js";
 import "../chunk-DGUM43GV.js";
 
+// src/ingest/agent-builder.ts
+import Anthropic2 from "@anthropic-ai/sdk";
+
+// src/ingest/document-parser.ts
+import { readFile } from "fs/promises";
+import { extname, basename } from "path";
+async function parseDocument(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  const fileType = getFileType(ext);
+  if (!fileType) {
+    throw new Error(`Unsupported file type: ${ext}. Supported: .pdf, .txt, .md, .rtf`);
+  }
+  let rawText;
+  let metadata = {
+    fileType,
+    originalPath: filePath,
+    parsedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  switch (fileType) {
+    case "pdf":
+      const pdfResult = await parsePDF(filePath);
+      rawText = pdfResult.text;
+      metadata.pageCount = pdfResult.pageCount;
+      if (pdfResult.title !== void 0) {
+        metadata.title = pdfResult.title;
+      }
+      break;
+    case "txt":
+      rawText = await parseTXT(filePath);
+      break;
+    case "md":
+      rawText = await parseMarkdown(filePath);
+      break;
+    case "rtf":
+      rawText = await parseRTF(filePath);
+      break;
+    default:
+      throw new Error(`Unsupported file type: ${fileType}`);
+  }
+  metadata.wordCount = countWords(rawText);
+  const sections = extractSections(rawText, fileType);
+  if (!metadata.title) {
+    metadata.title = extractTitle(rawText, sections) || basename(filePath, ext);
+  }
+  return {
+    rawText,
+    metadata,
+    sections
+  };
+}
+function getFileType(ext) {
+  const typeMap = {
+    ".pdf": "pdf",
+    ".txt": "txt",
+    ".md": "md",
+    ".markdown": "md",
+    ".rtf": "rtf"
+  };
+  return typeMap[ext] || null;
+}
+async function parsePDF(filePath) {
+  try {
+    const pdfParse = (await import("pdf-parse")).default;
+    const dataBuffer = await readFile(filePath);
+    const data = await pdfParse(dataBuffer);
+    const result = {
+      text: data.text,
+      pageCount: data.numpages
+    };
+    if (data.info?.Title) {
+      result.title = data.info.Title;
+    }
+    return result;
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        "PDF parsing requires the pdf-parse package. Install it with: npm install pdf-parse"
+      );
+    }
+    throw error;
+  }
+}
+async function parseTXT(filePath) {
+  return await readFile(filePath, "utf-8");
+}
+async function parseMarkdown(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return content.replace(/^[-*_]{3,}$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function parseRTF(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return stripRTF(content);
+}
+function stripRTF(rtf) {
+  let text = rtf.replace(/^{\\rtf1[^}]*}/i, "");
+  text = text.replace(/\\[a-z]+(-?\d+)?[ ]?/gi, "");
+  text = text.replace(/{[^{}]*}/g, "");
+  text = text.replace(/\\'([0-9a-f]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/\\par\b/g, "\n").replace(/\\tab\b/g, "	").replace(/\\line\b/g, "\n").replace(/[{}\\]/g, "");
+  text = text.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return text;
+}
+function countWords(text) {
+  return text.split(/\s+/).filter((word) => word.length > 0).length;
+}
+function extractSections(text, fileType) {
+  const sections = [];
+  if (fileType === "md") {
+    const headingRegex = /^(#{1,6})\s+(.+)$/gm;
+    let match;
+    while ((match = headingRegex.exec(text)) !== null) {
+      const level = match[1].length;
+      const title = match[2].trim();
+      const startIndex = match.index;
+      if (sections.length > 0) {
+        const lastSection = sections[sections.length - 1];
+        lastSection.endIndex = startIndex;
+        lastSection.content = text.slice(
+          lastSection.startIndex,
+          startIndex
+        ).trim();
+      }
+      sections.push({
+        title,
+        level,
+        startIndex,
+        endIndex: text.length,
+        content: ""
+      });
+    }
+    if (sections.length > 0) {
+      const lastSection = sections[sections.length - 1];
+      lastSection.content = text.slice(
+        lastSection.startIndex
+      ).trim();
+    }
+  } else {
+    const chapterPatterns = [
+      /^chapter\s+(\d+|[ivxlc]+)[:\.\s]+(.*)$/gim,
+      /^section\s+(\d+|[ivxlc]+)[:\.\s]+(.*)$/gim,
+      /^part\s+(\d+|[ivxlc]+)[:\.\s]+(.*)$/gim,
+      /^(\d+)\.\s+([A-Z][^.]+)$/gm,
+      /^([A-Z][A-Z\s]+)$/gm
+      // ALL CAPS headings
+    ];
+    for (const pattern of chapterPatterns) {
+      let match;
+      pattern.lastIndex = 0;
+      while ((match = pattern.exec(text)) !== null) {
+        const title = match[2] || match[1] || match[0];
+        sections.push({
+          title: title.trim(),
+          level: 1,
+          startIndex: match.index,
+          endIndex: text.length,
+          content: ""
+        });
+      }
+      if (sections.length > 0) break;
+    }
+    sections.sort((a, b) => a.startIndex - b.startIndex);
+    for (let i = 0; i < sections.length; i++) {
+      const section = sections[i];
+      const nextSection = sections[i + 1];
+      const endIndex = nextSection !== void 0 ? nextSection.startIndex : text.length;
+      section.endIndex = endIndex;
+      section.content = text.slice(section.startIndex, endIndex).trim();
+    }
+  }
+  if (sections.length === 0) {
+    sections.push({
+      title: "Document Content",
+      level: 1,
+      startIndex: 0,
+      endIndex: text.length,
+      content: text.trim()
+    });
+  }
+  return sections;
+}
+function extractTitle(text, sections) {
+  const firstSection = sections[0];
+  if (firstSection !== void 0 && firstSection.title !== "Document Content") {
+    return firstSection.title;
+  }
+  const firstLine = text.split("\n")[0]?.trim();
+  if (firstLine && firstLine.length < 100 && !firstLine.includes(".")) {
+    return firstLine;
+  }
+  return null;
+}
+function chunkDocument(result, maxChunkSize = 4e3) {
+  const chunks = [];
+  if (result.rawText.length <= maxChunkSize) {
+    return [result.rawText];
+  }
+  if (result.sections.length > 1) {
+    let currentChunk = "";
+    for (const section of result.sections) {
+      const sectionText = `## ${section.title}
+
+${section.content}
+
+`;
+      if (currentChunk.length + sectionText.length > maxChunkSize) {
+        if (currentChunk) chunks.push(currentChunk.trim());
+        if (sectionText.length > maxChunkSize) {
+          chunks.push(...splitByParagraphs(sectionText, maxChunkSize));
+          currentChunk = "";
+        } else {
+          currentChunk = sectionText;
+        }
+      } else {
+        currentChunk += sectionText;
+      }
+    }
+    if (currentChunk) chunks.push(currentChunk.trim());
+  } else {
+    chunks.push(...splitByParagraphs(result.rawText, maxChunkSize));
+  }
+  return chunks;
+}
+function splitByParagraphs(text, maxSize) {
+  const chunks = [];
+  const paragraphs = text.split(/\n\s*\n/);
+  let currentChunk = "";
+  for (const para of paragraphs) {
+    if (currentChunk.length + para.length + 2 > maxSize) {
+      if (currentChunk) chunks.push(currentChunk.trim());
+      if (para.length > maxSize) {
+        chunks.push(...splitBySentences(para, maxSize));
+        currentChunk = "";
+      } else {
+        currentChunk = para;
+      }
+    } else {
+      currentChunk += (currentChunk ? "\n\n" : "") + para;
+    }
+  }
+  if (currentChunk) chunks.push(currentChunk.trim());
+  return chunks;
+}
+function splitBySentences(text, maxSize) {
+  const chunks = [];
+  const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
+  let currentChunk = "";
+  for (const sentence of sentences) {
+    if (currentChunk.length + sentence.length > maxSize) {
+      if (currentChunk) chunks.push(currentChunk.trim());
+      currentChunk = sentence;
+    } else {
+      currentChunk += sentence;
+    }
+  }
+  if (currentChunk) chunks.push(currentChunk.trim());
+  return chunks;
+}
+
+// src/ingest/knowledge-compressor.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/ingest/compression-prompts.ts
+var COMPRESSION_PROMPTS = {
+  /**
+   * System prompt for the knowledge extractor
+   */
+  system: `You are an expert knowledge extraction system. Your job is to analyze documents and extract structured, actionable knowledge that can be used by a code review agent.
+
+You must output valid JSON that matches the required schema exactly. Be thorough but concise - extract the essence of the knowledge without unnecessary verbosity.
+
+Focus on:
+1. Core concepts that are fundamental to understand the material
+2. Best practices that should be followed
+3. Anti-patterns and mistakes to avoid
+4. Detection patterns that could identify issues in code
+5. Key terminology and definitions`,
+  /**
+   * Prompt for extracting knowledge from a chunk
+   */
+  extractChunk: `Analyze this document chunk and extract structured knowledge.
+
+## Document Chunk:
+{{chunk}}
+
+## Instructions:
+Extract the following from this chunk:
+
+1. **Core Concepts**: Key ideas, principles, or rules that are taught
+2. **Best Practices**: Recommended approaches or patterns
+3. **Anti-Patterns**: Things to avoid, common mistakes
+4. **Code Patterns**: Any code patterns or detection rules that could identify issues
+5. **Terminology**: Important terms and their definitions
+
+Output as JSON:
+{
+  "coreConcepts": [
+    {
+      "name": "string",
+      "description": "string",
+      "importance": "critical" | "important" | "supplementary",
+      "keywords": ["string"]
+    }
+  ],
+  "bestPractices": [
+    {
+      "name": "string",
+      "description": "string",
+      "rationale": "string",
+      "codeExample": "string or null"
+    }
+  ],
+  "antiPatterns": [
+    {
+      "name": "string",
+      "description": "string",
+      "whyBad": "string",
+      "betterAlternative": "string"
+    }
+  ],
+  "codePatterns": [
+    {
+      "name": "string",
+      "description": "string",
+      "type": "best-practice" | "anti-pattern" | "security" | "compliance",
+      "regexHint": "string (a regex pattern that might detect this, or null)",
+      "keywords": ["string"]
+    }
+  ],
+  "terminology": {
+    "term": "definition"
+  }
+}
+
+Only include items that are clearly present in the chunk. Quality over quantity.`,
+  /**
+   * Prompt for merging extracted knowledge
+   */
+  mergeKnowledge: `Merge and deduplicate these knowledge extractions into a cohesive summary.
+
+## Extractions to Merge:
+{{extractions}}
+
+## Instructions:
+1. Combine similar concepts
+2. Remove duplicates
+3. Prioritize the most important items
+4. Ensure consistency in terminology
+5. Rank items by importance
+
+Output a single merged JSON with the same structure, keeping only the most valuable and distinct items.
+Limit to top 20 core concepts, 15 best practices, 15 anti-patterns, and 25 code patterns.`,
+  /**
+   * Prompt for generating detection rules
+   */
+  generateDetectionRules: `Based on this knowledge base, generate detection rules for a code review agent.
+
+## Knowledge Base:
+{{knowledge}}
+
+## Document Context:
+- Title: {{title}}
+- Domain: {{domain}}
+- Word Count: {{wordCount}}
+
+## Instructions:
+For each anti-pattern and best practice, generate detection rules that could find violations in code.
+
+For each rule, provide:
+1. A unique ID (format: {{prefix}}-XXX)
+2. Clear name and description
+3. Severity (critical, serious, moderate, low, info)
+4. Detection patterns:
+   - regex: Array of regex patterns (JavaScript-compatible)
+   - keywords: Words that might indicate this issue
+   - semantic: Natural language description for AI-based detection
+5. Fix information:
+   - description: How to fix
+   - example: Code example if applicable
+   - autoFixable: boolean
+
+Output as JSON array of detection rules:
+[
+  {
+    "id": "string",
+    "name": "string",
+    "description": "string",
+    "severity": "critical" | "serious" | "moderate" | "low" | "info",
+    "patterns": {
+      "regex": ["string"],
+      "keywords": ["string"],
+      "semantic": "string"
+    },
+    "fix": {
+      "description": "string",
+      "example": "string or null",
+      "autoFixable": boolean
+    },
+    "regulation": "string or null (for legal/compliance rules)",
+    "category": "string"
+  }
+]
+
+Generate 15-30 detection rules prioritizing the most impactful issues.`,
+  /**
+   * Prompt for generating agent prompts
+   */
+  generateAgentPrompts: `Generate system and analysis prompts for a code review agent based on this knowledge.
+
+## Knowledge Base Summary:
+{{summary}}
+
+## Core Concepts:
+{{concepts}}
+
+## Detection Focus:
+{{patterns}}
+
+## Agent Info:
+- Name: {{agentName}}
+- Category: {{category}}
+- Domain: {{domain}}
+
+## Instructions:
+Generate:
+1. A system prompt that gives the agent its persona and expertise
+2. An analysis prompt template for reviewing code
+3. A fix prompt template for suggesting fixes
+
+The prompts should:
+- Reference the specific knowledge from the document
+- Be authoritative but helpful
+- Include the key concepts and terminology
+- Guide the agent to look for the specific patterns
+
+Output as JSON:
+{
+  "systemPrompt": "string",
+  "analysisPrompt": "string (use {{code}}, {{filePath}}, {{language}} as placeholders)",
+  "fixPrompt": "string (use {{issue}}, {{code}}, {{filePath}} as placeholders)"
+}`,
+  /**
+   * Prompt for detecting document domain
+   */
+  detectDomain: `Analyze this document and determine its primary domain/category.
+
+## Document Title:
+{{title}}
+
+## Sample Content:
+{{sample}}
+
+## Instructions:
+Determine the primary domain of this document. Choose ONE:
+- "technical": Programming, frameworks, libraries, code patterns
+- "legal": Laws, regulations, compliance (GDPR, HIPAA, etc.)
+- "policy": Company policies, internal rules, guidelines
+- "security": Security practices, vulnerability prevention
+- "architecture": System design, patterns, architecture principles
+- "general": General knowledge, doesn't fit other categories
+
+Also determine:
+1. What types of code/files this knowledge applies to
+2. What context signals should trigger this agent
+3. Key content patterns to look for
+
+Output as JSON:
+{
+  "domain": "technical" | "legal" | "policy" | "security" | "architecture" | "general",
+  "filePatterns": ["*.ext", ...],
+  "contentPatterns": ["regex pattern", ...],
+  "contextSignals": ["touchesAuth", "touchesUI", ...],
+  "reasoning": "Brief explanation of why this domain was chosen"
+}`,
+  /**
+   * Prompt for generating a summary
+   */
+  generateSummary: `Create a concise executive summary of this document for use in an AI agent's context.
+
+## Document:
+{{content}}
+
+## Instructions:
+Write a 2-3 paragraph summary that:
+1. Explains what the document covers
+2. Highlights the most important takeaways
+3. Describes how this knowledge applies to code review
+
+The summary will be used as context for an AI code review agent, so focus on actionable insights.
+
+Keep it under 500 words.`
+};
+
+// src/ingest/knowledge-compressor.ts
+async function compressKnowledge(document, options) {
+  const { agentName, maxChunkSize = 4e3, verbose = false } = options;
+  const client = new Anthropic();
+  const log = verbose ? console.error.bind(console) : () => {
+  };
+  log("\u{1F4DA} Starting knowledge compression...");
+  log("   \u251C\u2500 Detecting document domain...");
+  const domainInfo = await detectDomain(client, document);
+  log(`   \u2502  \u2514\u2500 Domain: ${domainInfo.domain}`);
+  const chunks = chunkDocument(document, maxChunkSize);
+  log(`   \u251C\u2500 Document chunked into ${chunks.length} pieces`);
+  log("   \u251C\u2500 Extracting knowledge from chunks...");
+  const extractions = [];
+  for (let i = 0; i < chunks.length; i++) {
+    log(`   \u2502  \u251C\u2500 Processing chunk ${i + 1}/${chunks.length}...`);
+    try {
+      const chunk = chunks[i];
+      if (chunk !== void 0) {
+        const extraction = await extractFromChunk(client, chunk);
+        extractions.push(extraction);
+      }
+    } catch (error) {
+      log(`   \u2502  \u2502  \u2514\u2500 Warning: Failed to extract from chunk ${i + 1}`);
+    }
+  }
+  log("   \u251C\u2500 Merging and deduplicating knowledge...");
+  const mergedKnowledge = await mergeExtractions(client, extractions);
+  log("   \u251C\u2500 Generating detection rules...");
+  const detectionRules = await generateDetectionRules(
+    client,
+    mergedKnowledge,
+    document.metadata.title || agentName,
+    domainInfo.domain,
+    agentName
+  );
+  log(`   \u2502  \u2514\u2500 Generated ${detectionRules.length} detection rules`);
+  log("   \u2514\u2500 Generating knowledge summary...");
+  const summary = await generateSummary(client, document.rawText.slice(0, 8e3));
+  const compressed = {
+    domain: domainInfo.domain,
+    summary,
+    coreConcepts: mergedKnowledge.coreConcepts,
+    bestPractices: mergedKnowledge.bestPractices,
+    antiPatterns: mergedKnowledge.antiPatterns,
+    detectionRules,
+    glossary: mergedKnowledge.terminology,
+    sourceDocument: {
+      title: document.metadata.title || agentName,
+      wordCount: document.metadata.wordCount,
+      compressionRatio: Math.round(document.metadata.wordCount / (summary.length + JSON.stringify(detectionRules).length / 5))
+    }
+  };
+  return compressed;
+}
+async function detectDomain(client, document) {
+  const sampleSize = Math.min(document.rawText.length, 3e3);
+  const sample = document.rawText.slice(0, sampleSize);
+  const prompt = COMPRESSION_PROMPTS.detectDomain.replace("{{title}}", document.metadata.title || "Unknown").replace("{{sample}}", sample);
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 1e3,
+    system: COMPRESSION_PROMPTS.system,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const firstContent = response.content[0];
+  const text = firstContent !== void 0 && firstContent.type === "text" ? firstContent.text : "";
+  try {
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch (e) {
+  }
+  return {
+    domain: "general",
+    filePatterns: ["*"],
+    contentPatterns: [],
+    contextSignals: [],
+    reasoning: "Could not determine domain, using general"
+  };
+}
+async function extractFromChunk(client, chunk) {
+  const prompt = COMPRESSION_PROMPTS.extractChunk.replace("{{chunk}}", chunk);
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4e3,
+    system: COMPRESSION_PROMPTS.system,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const firstContent = response.content[0];
+  const text = firstContent !== void 0 && firstContent.type === "text" ? firstContent.text : "";
+  try {
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      return {
+        coreConcepts: parsed.coreConcepts || [],
+        bestPractices: parsed.bestPractices || [],
+        antiPatterns: parsed.antiPatterns || [],
+        codePatterns: parsed.codePatterns || [],
+        terminology: parsed.terminology || {}
+      };
+    }
+  } catch (e) {
+  }
+  return {
+    coreConcepts: [],
+    bestPractices: [],
+    antiPatterns: [],
+    codePatterns: [],
+    terminology: {}
+  };
+}
+async function mergeExtractions(client, extractions) {
+  if (extractions.length <= 2) {
+    return combineExtractions(extractions);
+  }
+  const prompt = COMPRESSION_PROMPTS.mergeKnowledge.replace("{{extractions}}", JSON.stringify(extractions, null, 2));
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 8e3,
+    system: COMPRESSION_PROMPTS.system,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const firstContent = response.content[0];
+  const text = firstContent !== void 0 && firstContent.type === "text" ? firstContent.text : "";
+  try {
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch (e) {
+  }
+  return combineExtractions(extractions);
+}
+function combineExtractions(extractions) {
+  const combined = {
+    coreConcepts: [],
+    bestPractices: [],
+    antiPatterns: [],
+    codePatterns: [],
+    terminology: {}
+  };
+  const seenConcepts = /* @__PURE__ */ new Set();
+  const seenPractices = /* @__PURE__ */ new Set();
+  const seenAntiPatterns = /* @__PURE__ */ new Set();
+  const seenPatterns = /* @__PURE__ */ new Set();
+  for (const extraction of extractions) {
+    for (const concept of extraction.coreConcepts) {
+      const key = concept.name.toLowerCase();
+      if (!seenConcepts.has(key)) {
+        seenConcepts.add(key);
+        combined.coreConcepts.push(concept);
+      }
+    }
+    for (const practice of extraction.bestPractices) {
+      const key = practice.name.toLowerCase();
+      if (!seenPractices.has(key)) {
+        seenPractices.add(key);
+        combined.bestPractices.push(practice);
+      }
+    }
+    for (const anti of extraction.antiPatterns) {
+      const key = anti.name.toLowerCase();
+      if (!seenAntiPatterns.has(key)) {
+        seenAntiPatterns.add(key);
+        combined.antiPatterns.push(anti);
+      }
+    }
+    for (const pattern of extraction.codePatterns) {
+      const key = pattern.name.toLowerCase();
+      if (!seenPatterns.has(key)) {
+        seenPatterns.add(key);
+        combined.codePatterns.push(pattern);
+      }
+    }
+    Object.assign(combined.terminology, extraction.terminology);
+  }
+  return combined;
+}
+async function generateDetectionRules(client, knowledge, title, domain, agentName) {
+  const prefix = agentName.toUpperCase().replace(/[^A-Z]/g, "").slice(0, 4) || "CUST";
+  const prompt = COMPRESSION_PROMPTS.generateDetectionRules.replace("{{knowledge}}", JSON.stringify(knowledge, null, 2)).replace("{{title}}", title).replace("{{domain}}", domain).replace("{{wordCount}}", String(knowledge.coreConcepts.length * 100)).replace(/\{\{prefix\}\}/g, prefix);
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 8e3,
+    system: COMPRESSION_PROMPTS.system,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const firstContent = response.content[0];
+  const text = firstContent !== void 0 && firstContent.type === "text" ? firstContent.text : "";
+  try {
+    const jsonMatch = text.match(/\[[\s\S]*\]/);
+    if (jsonMatch) {
+      const rules = JSON.parse(jsonMatch[0]);
+      return rules.map((rule, i) => ({
+        id: rule.id || `${prefix}-${String(i + 1).padStart(3, "0")}`,
+        name: rule.name || "Unknown Rule",
+        description: rule.description || "",
+        severity: rule.severity || "moderate",
+        patterns: {
+          regex: rule.patterns?.regex || [],
+          keywords: rule.patterns?.keywords || [],
+          semantic: rule.patterns?.semantic || ""
+        },
+        fix: {
+          description: rule.fix?.description || "Review and fix manually",
+          example: rule.fix?.example || void 0,
+          autoFixable: rule.fix?.autoFixable || false
+        },
+        regulation: rule.regulation || void 0,
+        category: rule.category || domain
+      }));
+    }
+  } catch (e) {
+    console.error("Failed to parse detection rules:", e);
+  }
+  return [];
+}
+async function generateSummary(client, content) {
+  const prompt = COMPRESSION_PROMPTS.generateSummary.replace("{{content}}", content);
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 1e3,
+    system: COMPRESSION_PROMPTS.system,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const firstContent = response.content[0];
+  return firstContent !== void 0 && firstContent.type === "text" ? firstContent.text : "";
+}
+async function generateAgentPrompts(client, knowledge, agentName, category) {
+  const prompt = COMPRESSION_PROMPTS.generateAgentPrompts.replace("{{summary}}", knowledge.summary).replace("{{concepts}}", JSON.stringify(knowledge.coreConcepts.slice(0, 10), null, 2)).replace("{{patterns}}", JSON.stringify(knowledge.detectionRules.slice(0, 10), null, 2)).replace("{{agentName}}", agentName).replace("{{category}}", category).replace("{{domain}}", knowledge.domain);
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4e3,
+    system: COMPRESSION_PROMPTS.system,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const firstContent = response.content[0];
+  const text = firstContent !== void 0 && firstContent.type === "text" ? firstContent.text : "";
+  try {
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch (e) {
+  }
+  return {
+    systemPrompt: `You are an expert code reviewer specializing in ${category}. Review code based on best practices and patterns from "${agentName}".`,
+    analysisPrompt: `Review this code for issues related to ${category}:
+
+\`\`\`{{language}}
+{{code}}
+\`\`\`
+
+File: {{filePath}}`,
+    fixPrompt: `Fix this issue: {{issue}}
+
+Code:
+\`\`\`{{language}}
+{{code}}
+\`\`\`
+
+File: {{filePath}}`
+  };
+}
+
+// src/ingest/agent-builder.ts
+import { mkdir, writeFile, readFile as readFile2 } from "fs/promises";
+import { join } from "path";
+async function buildAgentFromDocument(options, verbose = true) {
+  const { filePath, agentName, category } = options;
+  const log = verbose ? console.error.bind(console) : () => {
+  };
+  try {
+    log("\u{1F4DA} Parsing document...");
+    const document = await parseDocument(filePath);
+    log(`   \u251C\u2500 File type: ${document.metadata.fileType}`);
+    log(`   \u251C\u2500 Words: ${document.metadata.wordCount.toLocaleString()}`);
+    log(`   \u2514\u2500 Sections: ${document.sections.length}`);
+    log("\n\u{1F9E0} Compressing knowledge...");
+    const compressOptions = {
+      agentName,
+      verbose
+    };
+    if (category !== void 0) {
+      compressOptions.category = category;
+    }
+    const knowledge = await compressKnowledge(document, compressOptions);
+    log(`   \u251C\u2500 Core concepts: ${knowledge.coreConcepts.length}`);
+    log(`   \u251C\u2500 Best practices: ${knowledge.bestPractices.length}`);
+    log(`   \u251C\u2500 Anti-patterns: ${knowledge.antiPatterns.length}`);
+    log(`   \u2514\u2500 Detection rules: ${knowledge.detectionRules.length}`);
+    log("\n\u{1F4DD} Generating agent prompts...");
+    const client = new Anthropic2();
+    const prompts = await generateAgentPrompts(
+      client,
+      knowledge,
+      agentName,
+      category || knowledge.domain
+    );
+    log("\n\u{1F916} Building agent configuration...");
+    const agentConfig = buildAgentConfig(
+      document,
+      knowledge,
+      prompts,
+      options
+    );
+    const configPath = await saveAgentConfig(agentConfig);
+    log(`   \u2514\u2500 Saved to: ${configPath}`);
+    return {
+      success: true,
+      agentName: agentConfig.name,
+      configPath,
+      stats: {
+        documentWords: document.metadata.wordCount,
+        conceptsExtracted: knowledge.coreConcepts.length,
+        patternsGenerated: knowledge.detectionRules.length,
+        compressionRatio: knowledge.sourceDocument.compressionRatio
+      }
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`
+\u274C Error: ${errorMessage}`);
+    return {
+      success: false,
+      agentName,
+      configPath: "",
+      stats: {
+        documentWords: 0,
+        conceptsExtracted: 0,
+        patternsGenerated: 0,
+        compressionRatio: 0
+      },
+      error: errorMessage
+    };
+  }
+}
+function buildAgentConfig(document, knowledge, prompts, options) {
+  const { agentName, displayName, description, category } = options;
+  const docTitle = document.metadata.title;
+  const activationRules = buildActivationRules(knowledge);
+  return {
+    name: sanitizeAgentName(agentName),
+    displayName: displayName || formatDisplayName(agentName),
+    description: description || `Code review agent based on "${document.metadata.title || agentName}"`,
+    version: "1.0.0",
+    category: category || knowledge.domain,
+    source: {
+      type: "document",
+      originalFile: document.metadata.originalPath,
+      fileType: document.metadata.fileType,
+      compressedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...docTitle !== void 0 && { documentTitle: docTitle }
+    },
+    systemPrompt: prompts.systemPrompt,
+    analysisPrompt: prompts.analysisPrompt,
+    fixPrompt: prompts.fixPrompt,
+    activationRules,
+    patterns: knowledge.detectionRules,
+    knowledge
+  };
+}
+function buildActivationRules(knowledge) {
+  const domainRules = {
+    technical: {
+      filePatterns: ["*.ts", "*.tsx", "*.js", "*.jsx", "*.py", "*.go", "*.rs"],
+      contextSignals: ["touchesUI", "touchesAPI"],
+      priority: 2
+    },
+    legal: {
+      filePatterns: ["*"],
+      contextSignals: ["touchesUserData", "touchesAuth", "touchesPayments"],
+      priority: 2
+    },
+    policy: {
+      filePatterns: ["*"],
+      contextSignals: ["touchesAuth", "touchesAPI", "touchesDatabase"],
+      priority: 3
+    },
+    security: {
+      filePatterns: ["*"],
+      contextSignals: ["touchesAuth", "touchesCrypto", "touchesAPI", "touchesDatabase"],
+      priority: 1
+    },
+    architecture: {
+      filePatterns: ["*.ts", "*.tsx", "*.js", "*.jsx", "*.py", "*.go"],
+      contextSignals: ["touchesAPI", "touchesDatabase"],
+      priority: 2
+    },
+    general: {
+      filePatterns: ["*"],
+      contextSignals: [],
+      priority: 3
+    }
+  };
+  const domainDefaults = domainRules[knowledge.domain] ?? domainRules.general;
+  const contentPatterns = [];
+  for (const rule of knowledge.detectionRules) {
+    if (rule.patterns.keywords) {
+      contentPatterns.push(...rule.patterns.keywords.slice(0, 3));
+    }
+  }
+  for (const concept of knowledge.coreConcepts.slice(0, 5)) {
+    if (concept.keywords) {
+      contentPatterns.push(...concept.keywords.slice(0, 2));
+    }
+  }
+  const uniquePatterns = [...new Set(contentPatterns)].slice(0, 20);
+  return {
+    filePatterns: domainDefaults.filePatterns ?? ["*"],
+    contentPatterns: uniquePatterns,
+    contextSignals: domainDefaults.contextSignals ?? [],
+    minConfidence: 0.3,
+    priority: domainDefaults.priority ?? 2
+  };
+}
+async function saveAgentConfig(config) {
+  const trieDir = join(getTrieDirectory(getWorkingDirectory(void 0, true)), "agents");
+  await mkdir(trieDir, { recursive: true });
+  const configPath = join(trieDir, `${config.name}.json`);
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+  return configPath;
+}
+function sanitizeAgentName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function formatDisplayName(name) {
+  return name.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
 // src/cli/create-agent.ts
 import { existsSync } from "fs";
-import { resolve, basename, extname } from "path";
+import { resolve, basename as basename2, extname as extname2 } from "path";
 function parseArgs() {
   const args = process.argv.slice(2);
   if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
@@ -25,7 +949,7 @@ function parseArgs() {
   filePath = resolve(filePath);
   let agentName = args[1];
   if (!agentName || agentName.startsWith("--")) {
-    const filename = basename(filePath, extname(filePath));
+    const filename = basename2(filePath, extname2(filePath));
     agentName = filename.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
     console.log(`Auto-generated agent name: ${agentName}`);
   }
@@ -109,7 +1033,7 @@ async function main() {
     console.error("\nTip: Drag & drop the file directly into the terminal!");
     process.exit(1);
   }
-  const ext = extname(options.filePath).toLowerCase();
+  const ext = extname2(options.filePath).toLowerCase();
   const supportedTypes = [".pdf", ".txt", ".md", ".markdown", ".rtf"];
   if (!supportedTypes.includes(ext)) {
     console.error(`Unsupported file type: ${ext}`);