@triedotdev/mcp 1.0.86 → 1.0.88

package/README.md

@@ -1,26 +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.**
 
-[Download Workspace](https://www.trie.dev) · [Follow on X](https://x.com/louiskishfy)
+[![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
 
@@ -77,31 +77,31 @@ Trie remembers your decisions across tools, tracks the tradeoffs you've made, an
 
 ### Smart Memory
 
-Git-based storage - Your project's memory travels with your code in .trie/ folder  
-Cross-project learning - Patterns discovered in one project help prevent bugs in others  
-Incident tracking - Build a searchable history of what went wrong and why  
-Decision memory - Remembers architectural choices and tradeoffs across Cursor, Claude, VS Code, CLI, and CI/CD  
-Context that travels - Your thinking and planning keep up with code generation across all your tools
+- Git-based storage - Your project's memory travels with your code in `.trie/` folder.
+- Cross-project learning - Patterns discovered in one project help prevent bugs in others.
+- Incident tracking - Build a searchable history of what went wrong and why.
+- Decision memory - Remembers architectural choices and tradeoffs across Cursor, Claude, VS Code, CLI, and CI/CD.
+- Context that travels - Your thinking and planning keep up with code generation across all your tools.
 
 ### Intelligent Analysis
 
-26 built-in scouts - Automated analyzers for security, performance, accessibility, and more  
-Custom skills - Add external analyzers from the community  
-Risk scoring - Intelligent priority ranking based on your actual incident history  
-Edge case detection - Identifies recurring issues and patterns you've hit before  
-System coherence - Tracks relationships between files, changes, incidents, fixes, and decisions
+- 26 built-in scouts - Automated analyzers for security, performance, accessibility, and more.
+- Custom skills - Add external analyzers from the community.
+- Risk scoring - Intelligent priority ranking based on your actual incident history.
+- Edge case detection - Identifies recurring issues and patterns you've hit before.
+- System coherence - Tracks relationships between files, changes, incidents, fixes, and decisions.
 
 ### Development Integration
 
-Git hooks - Automatic checks before commits and pushes  
-Watch mode - Real-time monitoring while you code  
-Fast performance - Sub-500ms checks, won't slow down your workflow
+- Git hooks - Automatic checks before commits and pushes.
+- Watch mode - Real-time monitoring while you code.
+- Fast performance - Sub-500ms checks, won't slow down your workflow.
 
 ### Developer Experience
 
-Plain English warnings - "This auth change broke twice before" instead of cryptic codes  
-Multiple interfaces - CLI, MCP tools for Claude/Cursor, visual dashboards  
-Flexible workflow - Works with any editor, any git workflow, any deployment setup
+- Plain English warnings - "This auth change broke twice before" instead of cryptic codes.
+- Multiple interfaces - CLI, MCP tools for Claude/Cursor, visual dashboards.
+- Flexible workflow - Works with any editor, any git workflow, any deployment setup.
 
 ## How It Works
 
@@ -109,10 +109,10 @@ Flexible workflow - Works with any editor, any git workflow, any deployment setu
 
 Trie uses a "Guardian Agent" architecture:
 
-Scouts continuously analyze your code for potential issues  
-Guardian receives scout reports and decides what matters based on your history  
-Memory Tree stores incident patterns using a trie data structure for fast lookups  
-Learning Loop improves predictions based on your feedback
+- Scouts continuously analyze your code for potential issues.
+- Guardian receives scout reports and decides what matters based on your history.
+- Memory Tree stores incident patterns using a trie data structure for fast lookups.
+- Learning Loop improves predictions based on your feedback.
 
 ### Memory That Travels
 
@@ -148,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
@@ -482,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
@@ -1034,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 "path/to/file.ts" "This error handling prevented bugs"
+trie patterns save "path/*" "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 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

package/dist/{chunk-4UVTFL2T.js → chunk-4CYQGEWE.js}

@@ -8,7 +8,7 @@ import {
   getUncommittedChanges,
   getWorkingTreeDiff,
   loadConfig
-} from "./chunk-4U3DNRUA.js";
+} from "./chunk-YSES743V.js";
 import {
   ContextGraph
 } from "./chunk-THJKXIMJ.js";
@@ -1687,4 +1687,4 @@ export {
   LearningEngine,
   LinearIngester
 };
-//# sourceMappingURL=chunk-4UVTFL2T.js.map
+//# sourceMappingURL=chunk-4CYQGEWE.js.map

package/dist/{chunk-KERQ4JXR.js → chunk-HNDHVFA3.js}

@@ -5,14 +5,17 @@ import {
 import {
   Executor,
   Triager,
+  buildSavedPatternIssues,
   detectStack,
   getChangedFilesSinceTimestamp,
+  getDetectionRuleAgents,
   getSkillCategories,
   getSkillsByCategory,
   isGitRepo,
   isTrieInitialized,
-  loadConfig
-} from "./chunk-4U3DNRUA.js";
+  loadConfig,
+  loadSavedPatterns
+} from "./chunk-YSES743V.js";
 import {
   getVulnerabilityStats,
   getVulnerabilityTrie,
@@ -9285,6 +9288,7 @@ var TrieScanTool = class {
       this.logRiskAssessment(context, riskLevel);
       this.progress.startPhase("ai-review", "Selecting AI agents...");
       await this.ensureCustomSkillsLoaded();
+      const savedPatterns = await loadSavedPatterns(workDir);
       let selectedAgents = forceAgents ? this.agentRegistry.getAgentsByNames(forceAgents) : await this.triager.selectAgents(context, riskLevel);
       if (excludeAgents.size > 0) {
         const before = selectedAgents.length;
@@ -9294,6 +9298,17 @@ var TrieScanTool = class {
           console.error(`   Excluding ${removed} agent(s): ${Array.from(excludeAgents).join(", ")}`);
         }
       }
+      const savedDetectionAgents = getDetectionRuleAgents(savedPatterns).filter((agent) => !excludeAgents.has(agent));
+      if (savedDetectionAgents.length > 0) {
+        const selectedNames = new Set(selectedAgents.map((a) => a.name));
+        const extraAgents = this.agentRegistry.getAgentsByNames(savedDetectionAgents).filter((a) => !selectedNames.has(a.name));
+        if (extraAgents.length > 0) {
+          selectedAgents.push(...extraAgents);
+          if (!isInteractiveMode()) {
+            console.error(`   Added ${extraAgents.length} saved scout(s): ${extraAgents.map((a) => a.name).join(", ")}`);
+          }
+        }
+      }
       const allAgentNames = this.agentRegistry.getSkillNames();
       this.logTriaging(selectedAgents.map((a) => a.name), allAgentNames, context, riskLevel);
       this.progress.update(`${selectedAgents.length} agents selected for ${riskLevel} risk code`);
@@ -9343,6 +9358,23 @@ var TrieScanTool = class {
           timeoutMs
         }
       );
+      const savedPatternIssues = await buildSavedPatternIssues(
+        savedPatterns,
+        validFiles,
+        async (filePath) => readFile7(filePath, "utf-8")
+      );
+      if (savedPatternIssues.length > 0) {
+        agentResults.push({
+          agent: "saved-patterns",
+          issues: savedPatternIssues,
+          executionTime: 0,
+          success: true,
+          metadata: {
+            filesAnalyzed: validFiles.length,
+            linesAnalyzed: 0
+          }
+        });
+      }
       const allIssues = agentResults.flatMap((result2) => result2.issues);
       const issueAnalyzer = new IssueAnalyzer();
       const priorityReport = issueAnalyzer.analyzeIssues(allIssues);
@@ -9983,4 +10015,4 @@ export {
   InteractiveDashboard,
   TrieScanTool
 };
-//# sourceMappingURL=chunk-KERQ4JXR.js.map
+//# sourceMappingURL=chunk-HNDHVFA3.js.map