@triedotdev/mcp 1.0.87 → 1.0.89

package/README.md

@@ -1,29 +1,26 @@
 # Trie: Trainable AI Agent for Maintaining AI-Generated Codebases
 
-A trainable AI agent that watches all of your codebases, learns from your incidents, and prevents repeat bugs before they ship.
+**A trainable AI agent that watches all of your codebases, learns from your incidents, and prevents repeat bugs before they ship.**
 
-<p align="left">
-  <a href="https://www.trie.dev"><img alt="Download Workspace" src="https://img.shields.io/badge/Download_Workspace-0b0f14?style=for-the-badge&logo=vercel&logoColor=white"></a>
-  <a href="https://x.com/louiskishfy"><img alt="Follow on X" src="https://img.shields.io/badge/Follow_on_X-000000?style=for-the-badge&logo=x&logoColor=white"></a>
-</p>
+[![Download Workspace](https://img.shields.io/badge/Download-Trie%20Workspace-blue)](https://www.trie.dev) [![Follow on X](https://img.shields.io/badge/Follow-@louiskishfy-1DA1F2?logo=x)](https://x.com/louiskishfy)
 
 ## What Trie Does
 
-- Central skill repository: One place for all your skills — carry context and rules across Cursor, Claude, VS Code, CLI, and CI/CD. Unlike running skills with Claude Code, Trie will check for anything malicious before you run them.
-- Sets and tracks goals: "Reduce login bugs by 50%" then actually measures progress and celebrates wins.
-- Tests your theories: "Mondays have more bugs" — Trie validates with real data and builds confidence over time.
-- Learns from your incidents: Train it on your specific patterns, not generic rules that don't fit your prompting.
-- Predicts "Gotchas" proactively: Ingests Linear tickets and correlates them with past failures to warn you before you even push code.
+- **Central skill repository**: One place for all your skills — carry context and rules across Cursor, Claude, VS Code, CLI, and CI/CD. Unlike running skills with Claude Code, Trie will check for anything malicious before you run them.
+- **Sets and tracks goals**: "Reduce login bugs by 50%" then actually measures progress and celebrates wins
+- **Tests your theories**: "Mondays have more bugs" — Trie validates with real data and builds confidence over time
+- **Learns from your incidents**: Train it on your specific patterns, not generic rules that don't fit your prompting
+- **Predicts "Gotchas" proactively**: Ingests Linear tickets and correlates them with past failures to warn you before you even push code
 
 ## Goal
 
-Trie exists so you can maintain multiple codebases as one person without losing your mind.
+Trie exists so you can maintain multiple codebases as one person without losing your mind. 
 
 Every bug you fix teaches Trie a pattern that protects all your projects. Every incident you report becomes institutional knowledge that travels with your code. Every decision you make—and the tradeoffs you considered—gets remembered across Cursor, Claude, VS Code, CLI, and CI/CD.
 
 Instead of burning tokens on the same questions across different repos or forgetting why you architected something a certain way six months ago, Trie remembers for you. Instead of losing track of edge cases and tradeoffs as you switch between tools, Trie maintains system coherence. The result is faster development with fewer production fires, because your personal AI agent gets smarter every time something breaks instead of starting from zero in every conversation.
 
-Your thinking and planning keep up with code generation. Your decisions persist across tools. Your edge cases don't get forgotten.
+**Your thinking and planning keep up with code generation. Your decisions persist across tools. Your edge cases don't get forgotten.**
 
 ## Quick Start
 
@@ -151,6 +148,22 @@ When you switch from Cursor to Claude Code to terminal, Trie remembers. Your thi
 
 ## Core Workflow
 
+### 0. Planning Phase
+
+**Start every complex task by checking Trie first.** Just like starting in plan mode helps Claude 1-shot implementation, checking Trie before coding helps you avoid known pitfalls:
+
+```bash
+# Before starting work on a feature, check what broke before
+trie gotcha                    # Predict risks for current changes
+trie memory search "auth"      # See past incidents in this area
+trie status                   # Check overall project health
+
+# Review past decisions and tradeoffs
+# Trie's Context Graph remembers why you made choices and what happened
+```
+
+**Pro tip:** The moment something goes sideways, check Trie again. Don't keep pushing—re-plan with historical context. Trie shows you what broke before, what decisions were made, and what edge cases caused issues. Use that knowledge to inform your plan, then let your AI tools implement it.
+
 ### 1. Teaching Phase
 
 ```bash
@@ -485,6 +498,38 @@ git push --no-verify              # Skip all hooks
 TRIE_BYPASS=1 git push           # Skip Trie but log bypass
 ```
 
+### Slack Integration
+
+Trie sends notifications to Slack for team collaboration:
+
+**Setup:**
+1. Create a Slack webhook: https://api.slack.com/apps
+2. Add to `.trie/config.json`:
+
+```json
+{
+  "integrations": {
+    "slack": {
+      "enabled": true,
+      "webhook": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
+      "channel": "#security"  // Optional: default channel
+    }
+  },
+  "autoEscalation": {
+    "enabled": true,
+    "webhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
+    "quietHours": { "start": "21:00", "end": "08:00" }
+  }
+}
+```
+
+**What Trie sends to Slack:**
+- Scan completion notifications with issue counts
+- Critical security alerts (immediate)
+- Daily/weekly team summaries
+- Escalation notifications for overdue issues
+- Bulk fix notifications
+
 ## CI/CD Integration
 
 ### GitHub Actions
@@ -1037,6 +1082,37 @@ trie learn       # Learn from your git history
 trie pause       # Disable warnings for 1 hour
 ```
 
+### Pattern Sharing
+Save, validate, and share patterns that worked well across projects:
+
+```bash
+# Save patterns (auto-detects type: file structure, code pattern, or detection rule)
+trie patterns save "auth/login.ts" "This error handling prevented 3 bugs"
+trie patterns save "auth/*" "This folder structure worked well"
+trie patterns save security "This scout caught issues early"
+
+# List saved patterns
+trie patterns list
+trie patterns list --validated  # Only validated patterns
+
+# Validate a pattern (mark as "worked great")
+trie patterns validate pattern-abc123 "Worked great in production"
+
+# Export patterns to share
+trie patterns export my-patterns.json --validated
+
+# Import patterns into another project
+cd ../another-project
+trie patterns import ../source-project/patterns.json
+```
+
+**Smart Pattern Detection:**
+- **File structure patterns** - Architecture decisions (`path/*`, `*.ts`)
+- **Code patterns** - Specific fixes/approaches that worked (`path/to/file.ts`)
+- **Detection rules** - Scout configurations that caught issues (`security`, `privacy`)
+
+Saved patterns are automatically applied during `trie scan` and `trie watch` runs.
+
 ### Watch Mode
 ```bash
 trie watch       # Start interactive monitoring dashboard
@@ -1112,6 +1188,14 @@ Global patterns stored in `~/.trie/memory/`:
 - Skill effectiveness data
 - Your personal coding patterns
 
+### Git Worktrees
+Trie is worktree-aware and shares a single `.trie/` across linked worktrees by default.
+
+If you want isolated memory per worktree, set:
+```
+TRIE_WORKTREE_MODE=isolated
+```
+
 ### Memory Management
 ```bash
 # View capacity (default: 10,000 issues)

package/dist/{agent-smith-MCKGNWPL.js → agent-smith-KIFP2XG3.js}

@@ -1,9 +1,9 @@
 import {
   AgentSmithSkill,
   PATTERN_HUNTER_CONFIGS
-} from "./chunk-TBRU735C.js";
-import "./chunk-DCJKNE2L.js";
-import "./chunk-CM7EHNQK.js";
+} from "./chunk-F3WW4FY2.js";
+import "./chunk-GMKPXL4Q.js";
+import "./chunk-D5VEUZLP.js";
 import "./chunk-MIL54SAF.js";
 import "./chunk-DGUM43GV.js";
 export {
@@ -11,4 +11,4 @@ export {
   AgentSmithSkill,
   PATTERN_HUNTER_CONFIGS
 };
-//# sourceMappingURL=agent-smith-MCKGNWPL.js.map
+//# sourceMappingURL=agent-smith-KIFP2XG3.js.map

package/dist/{agent-smith-runner-GP5HLL7E.js → agent-smith-runner-Z73W5DR5.js}

@@ -1,14 +1,14 @@
 import {
   AgentSmithSkill
-} from "./chunk-TBRU735C.js";
+} from "./chunk-F3WW4FY2.js";
 import {
   getAIStatusMessage,
   isAIAvailable,
   runAIAnalysis
-} from "./chunk-DCJKNE2L.js";
+} from "./chunk-GMKPXL4Q.js";
 import {
   getWorkingDirectory
-} from "./chunk-CM7EHNQK.js";
+} from "./chunk-D5VEUZLP.js";
 import {
   isInteractiveMode
 } from "./chunk-MIL54SAF.js";
@@ -570,4 +570,4 @@ ${getAIStatusMessage()}`);
 export {
   runAgentSmith
 };
-//# sourceMappingURL=agent-smith-runner-GP5HLL7E.js.map
+//# sourceMappingURL=agent-smith-runner-Z73W5DR5.js.map

package/dist/{chunk-4U3DNRUA.js → chunk-3HTPH3P2.js}

@@ -3,18 +3,20 @@ import {
   getSkillRegistry,
   loadContextState,
   runExecFile
-} from "./chunk-Z6JP2QQU.js";
+} from "./chunk-BBEFK56U.js";
 import {
   getGlobalMemoryStats
-} from "./chunk-KGVKUMFO.js";
+} from "./chunk-D35TI7NY.js";
 import {
   getHistoricalInsights,
   getMemoryStats,
-  getRecentIssues
-} from "./chunk-7UPNCM66.js";
+  getRecentIssues,
+  searchIssues
+} from "./chunk-JG2TAVAO.js";
 import {
+  getTrieDirectory,
   getWorkingDirectory
-} from "./chunk-CM7EHNQK.js";
+} from "./chunk-D5VEUZLP.js";
 import {
   isInteractiveMode
 } from "./chunk-MIL54SAF.js";
@@ -35,7 +37,7 @@ var INIT_MARKERS = [
 ];
 function isTrieInitialized(workDir) {
   const dir = workDir || getWorkingDirectory(void 0, true);
-  const trieDir = join(dir, ".trie");
+  const trieDir = getTrieDirectory(dir);
   return INIT_MARKERS.some((marker) => existsSync(join(trieDir, marker)));
 }
 
@@ -183,7 +185,7 @@ var ConfigValidator = class {
     let anthropicKey = process.env.ANTHROPIC_API_KEY;
     if (!anthropicKey) {
       try {
-        const configPath = join2(getWorkingDirectory(void 0, true), ".trie", "config.json");
+        const configPath = join2(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
         if (existsSync2(configPath)) {
           const config = JSON.parse(readFileSync(configPath, "utf-8"));
           anthropicKey = config.apiKeys?.anthropic;
@@ -419,7 +421,7 @@ var DEFAULT_CONFIG = {
 // src/config/loader.ts
 async function loadConfig() {
   const validator = new ConfigValidator();
-  const configPath = join3(getWorkingDirectory(void 0, true), ".trie", "config.json");
+  const configPath = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
   try {
     if (!existsSync3(configPath)) {
       return DEFAULT_CONFIG;
@@ -455,7 +457,7 @@ async function loadConfig() {
   }
 }
 async function saveConfig(config) {
-  const configPath = join3(getWorkingDirectory(void 0, true), ".trie", "config.json");
+  const configPath = join3(getTrieDirectory(getWorkingDirectory(void 0, true)), "config.json");
   const dir = dirname(configPath);
   if (!existsSync3(dir)) {
     await mkdir(dir, { recursive: true });
@@ -1413,7 +1415,7 @@ var CacheManager = class {
   // 24 hours
   MAX_ENTRIES = 1e3;
   constructor(baseDir) {
-    this.cacheDir = join4(baseDir, ".trie", "cache");
+    this.cacheDir = join4(getTrieDirectory(baseDir), "cache");
     this.indexPath = join4(this.cacheDir, "index.json");
   }
   /**
@@ -2227,6 +2229,199 @@ function getSkillCategories() {
   }));
 }
 
+// src/patterns/saved-patterns.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { join as join6, basename } from "path";
+async function loadSavedPatterns(workDir) {
+  const patternsPath = join6(getTrieDirectory(workDir), "saved-patterns.json");
+  try {
+    if (existsSync7(patternsPath)) {
+      const content = await readFile4(patternsPath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return [];
+}
+async function savePatternsToProject(patterns, workDir) {
+  const { mkdir: mkdir3 } = await import("fs/promises");
+  const patternsPath = join6(getTrieDirectory(workDir), "saved-patterns.json");
+  await mkdir3(getTrieDirectory(workDir), { recursive: true });
+  await writeFile3(patternsPath, JSON.stringify(patterns, null, 2));
+}
+async function savePatternToProject(pattern, workDir) {
+  const patterns = await loadSavedPatterns(workDir);
+  const existing = patterns.findIndex((p) => p.id === pattern.id);
+  if (existing >= 0) {
+    patterns[existing] = {
+      ...patterns[existing],
+      ...pattern,
+      occurrences: patterns[existing].occurrences + 1
+    };
+  } else {
+    patterns.push(pattern);
+  }
+  await savePatternsToProject(patterns, workDir);
+}
+function detectPatternType(target, workDir) {
+  const scoutNames = [
+    "security",
+    "privacy",
+    "legal",
+    "accessibility",
+    "bug-finding",
+    "architecture",
+    "types",
+    "clean",
+    "devops",
+    "performance",
+    "ux",
+    "design",
+    "production-ready",
+    "agent-smith"
+  ];
+  if (scoutNames.includes(target.toLowerCase())) {
+    return "detection-rule";
+  }
+  const fullPath = join6(workDir, target);
+  if (existsSync7(fullPath) || target.includes("/") || target.includes("*") || target.endsWith(".ts") || target.endsWith(".js")) {
+    return "file-structure";
+  }
+  return "code-pattern";
+}
+function generatePatternId(target, type) {
+  const hash = createHash2("sha256").update(`${type}:${target}`).digest("hex").slice(0, 12);
+  return `${type}-${hash}`;
+}
+function getDetectionRuleAgents(patterns) {
+  return patterns.filter((p) => p.type === "detection-rule").map((p) => p.detectionRule?.agent || p.name).filter(Boolean);
+}
+async function createSavedPattern(target, note, workDir) {
+  const projectName = basename(workDir);
+  const patternType = detectPatternType(target, workDir);
+  const savedPattern = {
+    id: generatePatternId(target, patternType),
+    type: patternType,
+    name: target,
+    description: note || `Pattern saved from ${projectName}`,
+    validated: false,
+    projects: [projectName],
+    occurrences: 1,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    savedBy: projectName
+  };
+  if (patternType === "file-structure") {
+    savedPattern.filePatterns = [target];
+    savedPattern.architecture = {
+      structure: `Files matching ${target}`,
+      rationale: note || "File structure pattern that worked well"
+    };
+  } else if (patternType === "code-pattern") {
+    const issues = await searchIssues(target, { limit: 5 });
+    if (issues.length > 0) {
+      const latestIssue = issues[0];
+      savedPattern.codePattern = {
+        pattern: latestIssue?.issue.issue || target,
+        fix: latestIssue?.issue.fix || "Review and apply similar fix",
+        context: note || "Code pattern that worked well"
+      };
+    } else {
+      savedPattern.codePattern = {
+        pattern: target,
+        fix: "Review and apply similar fix",
+        context: note || "Code pattern that worked well"
+      };
+    }
+  } else if (patternType === "detection-rule") {
+    savedPattern.detectionRule = {
+      agent: target,
+      rule: `Detection rules from ${target} scout`,
+      severity: "moderate"
+    };
+  }
+  return savedPattern;
+}
+async function buildSavedPatternIssues(patterns, files, readFileContent) {
+  const issues = [];
+  for (const pattern of patterns) {
+    if (pattern.type === "detection-rule") continue;
+    const targetFiles = filterFilesForPattern(files, pattern);
+    if (targetFiles.length === 0) continue;
+    if (pattern.type === "file-structure") {
+      for (const file of targetFiles) {
+        issues.push(createPatternIssue(pattern, file, void 0));
+      }
+      continue;
+    }
+    if (pattern.type === "code-pattern" && pattern.codePattern) {
+      for (const file of targetFiles) {
+        const content = await readFileContent(file);
+        const match = findPatternMatch(content, pattern.codePattern.pattern);
+        if (match) {
+          issues.push(createPatternIssue(pattern, file, match.line));
+        }
+      }
+    }
+  }
+  return issues;
+}
+function filterFilesForPattern(files, pattern) {
+  if (pattern.type === "file-structure" && pattern.filePatterns) {
+    return files.filter((file) => pattern.filePatterns.some((p) => matchesFilePattern(file, p)));
+  }
+  if (pattern.type === "code-pattern") {
+    return files;
+  }
+  return [];
+}
+function matchesFilePattern(filePath, pattern) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLESTAR___").replace(/\*/g, "[^/]*").replace(/___DOUBLESTAR___/g, ".*");
+  const regex = new RegExp(`^${escaped}$`, "i");
+  return regex.test(normalized) || normalized.includes(pattern.replace(/\*+/g, ""));
+}
+function findPatternMatch(content, pattern) {
+  try {
+    const regex = new RegExp(pattern, "i");
+    const match = regex.exec(content);
+    if (!match || match.index === void 0) return null;
+    const line = getLineNumber(content, match.index);
+    return { line };
+  } catch {
+    const index = content.toLowerCase().indexOf(pattern.toLowerCase());
+    if (index === -1) return null;
+    const line = getLineNumber(content, index);
+    return { line };
+  }
+}
+function getLineNumber(content, index) {
+  return content.slice(0, index).split("\n").length;
+}
+function createPatternIssue(pattern, file, line) {
+  const description = pattern.description || `Saved pattern: ${pattern.name}`;
+  const fix = pattern.codePattern?.fix || "Apply the saved pattern from your other project.";
+  const issue = {
+    id: `saved-${pattern.id}-${hashFile(file)}`,
+    severity: "low",
+    issue: `Saved pattern suggestion: ${description}`,
+    fix,
+    file,
+    confidence: 0.6,
+    autoFixable: false,
+    agent: "saved-patterns",
+    category: "pattern-sharing"
+  };
+  if (line !== void 0) {
+    issue.line = line;
+  }
+  return issue;
+}
+function hashFile(file) {
+  return createHash2("sha256").update(file).digest("hex").slice(0, 8);
+}
+
 export {
   loadConfig,
   saveConfig,
@@ -2243,6 +2438,12 @@ export {
   SKILL_CATEGORIES,
   detectStack,
   getSkillsByCategory,
-  getSkillCategories
+  getSkillCategories,
+  loadSavedPatterns,
+  savePatternsToProject,
+  savePatternToProject,
+  getDetectionRuleAgents,
+  createSavedPattern,
+  buildSavedPatternIssues
 };
-//# sourceMappingURL=chunk-4U3DNRUA.js.map
+//# sourceMappingURL=chunk-3HTPH3P2.js.map