@triedotdev/mcp 1.0.113 → 1.0.115

package/dist/index.js

@@ -19,6 +19,9 @@ import {
   projectInfoExists,
   updateProjectSection
 } from "./chunk-TKMV7JKN.js";
+import {
+  getAutonomyConfig
+} from "./chunk-I2GFI3AM.js";
 import {
   ExtractionPipeline,
   InteractiveDashboard,
@@ -32,33 +35,31 @@ import {
   TrieQueryContextTool,
   TrieScanTool,
   TrieTellTool,
-  getOutputManager,
   getPrompt,
   getSystemPrompt,
   handleCheckpointTool
-} from "./chunk-2764KZZQ.js";
-import "./chunk-SDS3UVFY.js";
+} from "./chunk-ZYKEILVK.js";
+import "./chunk-AOFYU6T3.js";
+import "./chunk-2SIFK7OW.js";
+import "./chunk-DZREHOGW.js";
+import "./chunk-6LXSA2OZ.js";
 import {
   exportToJson,
   formatFriendlyError,
   importFromJson,
   isTrieInitialized,
   runShellCommandSync
-} from "./chunk-QYOACM2C.js";
+} from "./chunk-MVNJPJBK.js";
 import {
-  ContextGraph,
   findCrossProjectPatterns,
   getGlobalMemoryStats,
-  isAIAvailable,
   listTrackedProjects,
-  runAIAnalysis,
   searchGlobalPatterns
-} from "./chunk-6QR6QZIX.js";
-import "./chunk-IXO4G4D3.js";
+} from "./chunk-D3EXBJE2.js";
 import {
-  getSkillRegistry
-} from "./chunk-G76DYVGX.js";
-import "./chunk-33WL3D7A.js";
+  isAIAvailable,
+  runAIAnalysis
+} from "./chunk-SWSK7ANT.js";
 import {
   findSimilarIssues,
   getMemoryStats,
@@ -66,13 +67,28 @@ import {
   markIssueResolved,
   purgeIssues,
   searchIssues
-} from "./chunk-6JPPYG7F.js";
+} from "./chunk-55DOQNHJ.js";
+import "./chunk-KRH642MT.js";
+import "./chunk-F4NJ4CBP.js";
+import "./chunk-IXO4G4D3.js";
+import {
+  ContextGraph
+} from "./chunk-NS2MSZMB.js";
+import "./chunk-2GIAROBF.js";
+import "./chunk-6NLHFIYA.js";
+import "./chunk-ZV2K6M7T.js";
+import {
+  getSkillRegistry
+} from "./chunk-G76DYVGX.js";
+import {
+  getOutputManager
+} from "./chunk-VRLMTOB6.js";
+import "./chunk-YR4BMGYO.js";
+import "./chunk-43X6JBEM.js";
 import {
   getTrieDirectory,
   getWorkingDirectory
 } from "./chunk-R4AAPFXC.js";
-import "./chunk-F4NJ4CBP.js";
-import "./chunk-6NLHFIYA.js";
 import {
   isInteractiveMode
 } from "./chunk-APMV77PU.js";
@@ -1120,7 +1136,6 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
 ]);
 var TrieWatchTool = class _TrieWatchTool {
   extractionPipeline = null;
-  static DEFAULT_HOURLY_TOKEN_LIMIT = 5e4;
   state = {
     isRunning: false,
     lastScan: /* @__PURE__ */ new Map(),
@@ -1136,7 +1151,7 @@ var TrieWatchTool = class _TrieWatchTool {
     tokenBudget: {
       used: 0,
       windowStart: Date.now(),
-      hourlyLimit: _TrieWatchTool.DEFAULT_HOURLY_TOKEN_LIMIT,
+      hourlyLimit: 5e4,
       scansSaved: 0
     },
     cleanFiles: /* @__PURE__ */ new Map()
@@ -1144,6 +1159,9 @@ var TrieWatchTool = class _TrieWatchTool {
   watchers = /* @__PURE__ */ new Map();
   streamingManager = void 0;
   dashboard = void 0;
+  lastHypothesisCheck = 0;
+  static HYPOTHESIS_CHECK_INTERVAL_MS = 3e5;
+  // Check every 5 minutes
   async execute(args) {
     const { action, directory, debounceMs = 1e3 } = args;
     switch (action) {
@@ -1309,6 +1327,8 @@ Detected changes in ${files.length} file(s):`);
       console.error("");
     }
     try {
+      const projectPath = getWorkingDirectory(void 0, true);
+      await this.checkGoalViolations(files, projectPath);
       if (this.extractionPipeline) {
         try {
           const fileContents = await Promise.all(
@@ -1355,8 +1375,12 @@ ${f.content.slice(0, 1e3)}`
           }
         }
       }
-      if (!this.isQuiet()) {
-        this.autoScanFiles(files);
+      this.autoScanFiles(files);
+      await this.discoverPatternsFromIssues(projectPath);
+      const now = Date.now();
+      if (now - this.lastHypothesisCheck > _TrieWatchTool.HYPOTHESIS_CHECK_INTERVAL_MS) {
+        this.checkAndGenerateHypotheses(projectPath);
+        this.lastHypothesisCheck = now;
       }
       if (this.streamingManager) {
         for (const file of files) {
@@ -1385,9 +1409,238 @@ ${f.content.slice(0, 1e3)}`
       return false;
     }
   }
-  static AUTO_SCAN_COOLDOWN_MS = 3e4;
-  static CLEAN_FILE_COOLDOWN_MS = 3e5;
-  // skip files clean-scanned in last 5 min
+  /**
+   * Check file changes against active user goals
+   * If violations found: record to ledger, nudge user, auto-fix if enabled
+   */
+  async checkGoalViolations(files, projectPath) {
+    try {
+      const { validateAgainstGoals, recordGoalViolationCaught, recordGoalViolationFixed } = await import("./goal-validator-T5HEYBC5.js");
+      const { appendIssuesToLedger } = await import("./ledger-SR6OEBLO.js");
+      const { getAutonomyConfig: getAutonomyConfig2 } = await import("./autonomy-config-JXB7WCZ2.js");
+      const { applyAutoFix } = await import("./auto-fix-apply-PCAHWLXF.js");
+      const config = await getAutonomyConfig2(projectPath);
+      const outputMgr = getOutputManager();
+      for (const file of files) {
+        try {
+          const content = await readFile3(file, "utf-8");
+          const result = await validateAgainstGoals(file, content, projectPath);
+          if (result.violations.length === 0) {
+            continue;
+          }
+          for (const violation of result.violations) {
+            const relativePath = file.replace(projectPath + "/", "");
+            const issue = {
+              id: `goal-violation-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+              hash: "",
+              file: relativePath,
+              line: violation.line,
+              agent: "goal-validator",
+              severity: violation.severity,
+              issue: violation.description,
+              fix: violation.autoFixable ? "Auto-fixable" : "Manual fix required",
+              category: "goal-violation",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              project: basename2(projectPath),
+              resolved: false,
+              resolvedAt: void 0
+            };
+            await appendIssuesToLedger([issue], projectPath);
+            await recordGoalViolationCaught(violation.goal, relativePath, projectPath);
+            const nudgeMessage = `Goal "${violation.goal.description}" violated: ${violation.violation} in ${basename2(file)}:${violation.line || "?"}`;
+            outputMgr.nudge(
+              nudgeMessage,
+              violation.severity === "critical" ? "critical" : "warning",
+              relativePath
+            );
+            this.state.nudges.push({
+              file: basename2(file),
+              message: nudgeMessage,
+              severity: violation.severity === "critical" ? "critical" : "high",
+              timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false })
+            });
+            if (!isInteractiveMode()) {
+              console.error(`   [!] Goal violation: ${violation.description}`);
+            }
+            if (config.autoFix.enabled && violation.autoFixable && violation.fixAction) {
+              if (!isInteractiveMode()) {
+                console.error(`   [*] Auto-fixing...`);
+              }
+              const fixed = await applyAutoFix(violation.fixAction);
+              if (fixed) {
+                await recordGoalViolationFixed(violation.goal, relativePath, projectPath);
+                const fixMessage = `Auto-fixed: ${violation.goal.description} violation in ${basename2(file)}`;
+                outputMgr.nudge(fixMessage, "info", relativePath, 5e3);
+                if (!isInteractiveMode()) {
+                  console.error(`   [+] Fixed automatically`);
+                }
+              }
+            }
+          }
+          if (this.streamingManager && result.violations.length > 0) {
+            this.streamingManager.reportSignalExtraction({
+              decisions: 0,
+              facts: 0,
+              blockers: result.violations.length,
+              questions: 0
+            });
+          }
+        } catch (error) {
+          outputMgr.log("warn", `Could not validate ${basename2(file)}: ${error}`);
+        }
+      }
+    } catch (error) {
+      getOutputManager().log("warn", `Goal validation error: ${error}`);
+    }
+  }
+  /**
+   * Check and generate hypotheses autonomously
+   * Claude observes patterns and creates new hypotheses to test
+   */
+  async checkAndGenerateHypotheses(projectPath) {
+    if (!isAIAvailable()) return;
+    try {
+      const { getHypothesisEngine } = await import("./hypothesis-KGC3P54C.js");
+      const { getOutputManager: getOutputManager2 } = await import("./output-manager-BOTMXSND.js");
+      const hypothesisEngine = getHypothesisEngine(projectPath);
+      const recentIssues = Array.from(this.state.issueCache.values()).flat();
+      const patterns = [];
+      const observations = [];
+      if (this.state.nudges.length > 0) {
+        const nudgesByFile = {};
+        for (const nudge of this.state.nudges) {
+          nudgesByFile[nudge.file] = (nudgesByFile[nudge.file] || 0) + 1;
+        }
+        const topFiles = Object.entries(nudgesByFile).sort(([, a], [, b]) => b - a).slice(0, 3);
+        if (topFiles[0] && topFiles[0][1] > 2) {
+          observations.push(`File ${topFiles[0][0]} has ${topFiles[0][1]} repeated issues this session`);
+        }
+      }
+      if (this.state.nudges.length > 5) {
+        observations.push(`High issue detection rate: ${this.state.nudges.length} violations detected in watch session`);
+      }
+      let generated = await hypothesisEngine.generateHypothesesWithAI({
+        recentIssues,
+        patterns,
+        observations
+      });
+      if (generated.length === 0) {
+        generated = await hypothesisEngine.autoGenerateHypotheses();
+      }
+      for (const hypothesis of generated) {
+        const message = `[New Hypothesis] "${hypothesis.statement}" (${Math.round(hypothesis.confidence * 100)}% confidence)`;
+        getOutputManager2().nudge(
+          message,
+          "info",
+          void 0,
+          1e4
+        );
+        if (!isInteractiveMode()) {
+          console.error(`
+   [?] ${message}`);
+          console.error(`       Test: ${hypothesis.testCriteria || "Collecting evidence..."}`);
+        }
+        if (this.streamingManager) {
+          this.streamingManager.reportSignalExtraction({
+            decisions: 0,
+            facts: 0,
+            blockers: 0,
+            questions: 1
+            // Hypotheses are questions to answer
+          });
+        }
+      }
+      if (recentIssues.length > 10) {
+        await hypothesisEngine.updateConfidenceFromOutcomes();
+      }
+    } catch (error) {
+      if (!isInteractiveMode()) {
+        console.error(`   [!] Hypothesis check failed: ${error}`);
+      }
+    }
+  }
+  /**
+   * Discover patterns from accumulated issues
+   * Patterns emerge naturally from your coding workflow
+   */
+  async discoverPatternsFromIssues(projectPath) {
+    const totalIssues = Array.from(this.state.issueCache.values()).flat().length;
+    if (totalIssues < 5) return;
+    try {
+      const { ContextGraph: ContextGraph2 } = await import("./graph-U5JWSAB5.js");
+      const { IncidentIndex } = await import("./incident-index-PNIVT47T.js");
+      const { TriePatternDiscovery } = await import("./pattern-discovery-F7LU5K6E.js");
+      const graph = new ContextGraph2(projectPath);
+      const incidentIndex = await IncidentIndex.build(graph, projectPath);
+      const discovery = new TriePatternDiscovery(graph, incidentIndex);
+      const hotPatterns = discovery.discoverHotPatterns(2);
+      for (const hot of hotPatterns) {
+        const existingPatterns = await graph.listNodes();
+        const alreadyExists = existingPatterns.some(
+          (n) => n.type === "pattern" && n.data.description?.includes(hot.path)
+        );
+        if (!alreadyExists) {
+          await graph.addNode("pattern", {
+            description: `${hot.type === "directory" ? "Directory" : "File"} hot zone: ${hot.path}`,
+            appliesTo: [hot.path],
+            confidence: Math.min(0.95, hot.confidence),
+            occurrences: hot.incidentCount,
+            firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+            lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+            isAntiPattern: hot.incidentCount >= 3,
+            // 3+ incidents = anti-pattern
+            source: "local"
+          });
+          if (!isInteractiveMode()) {
+            console.error(`   [+] Pattern discovered: ${hot.path} (${hot.incidentCount} issues)`);
+          }
+          if (this.streamingManager) {
+            this.streamingManager.reportSignalExtraction({
+              decisions: 0,
+              facts: 1,
+              // Patterns are facts about the codebase
+              blockers: 0,
+              questions: 0
+            });
+          }
+        }
+      }
+      if (totalIssues >= 10) {
+        const coOccurrences = await discovery.discoverCoOccurrences(2);
+        for (const coOcc of coOccurrences.slice(0, 3)) {
+          const desc = `Files break together: ${coOcc.files[0]} + ${coOcc.files[1]}`;
+          const existingPatterns = await graph.listNodes();
+          const alreadyExists = existingPatterns.some(
+            (n) => n.type === "pattern" && n.data.description === desc
+          );
+          if (!alreadyExists) {
+            await graph.addNode("pattern", {
+              description: desc,
+              appliesTo: [...coOcc.files],
+              confidence: Math.min(0.95, coOcc.confidence),
+              occurrences: coOcc.coOccurrences,
+              firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              isAntiPattern: coOcc.confidence > 0.7,
+              source: "local"
+            });
+            if (!isInteractiveMode()) {
+              console.error(`   [+] Co-occurrence pattern: ${coOcc.files[0]} + ${coOcc.files[1]}`);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (!isInteractiveMode()) {
+        console.error(`   [!] Pattern discovery failed: ${error}`);
+      }
+    }
+  }
+  // Defaults -- overridden by config when loaded
+  aiWatcherCooldownMs = 3e4;
+  cleanFileCooldownMs = 3e5;
+  maxFilesPerScan = 5;
+  maxCharsPerFile = 4e3;
   /**
    * Use the trie (context graph) to score how urgently a file needs scanning.
    * Higher score = more worth spending tokens on.
@@ -1395,7 +1648,7 @@ ${f.content.slice(0, 1e3)}`
   async scoreScanPriority(file, graph, projectPath) {
     let score = 1;
     const lastClean = this.state.cleanFiles.get(file);
-    if (lastClean && Date.now() - lastClean < _TrieWatchTool.CLEAN_FILE_COOLDOWN_MS) {
+    if (lastClean && Date.now() - lastClean < this.cleanFileCooldownMs) {
       return 0;
     }
     const fileNode = await graph.getNode("file", join2(projectPath, file));
@@ -1424,14 +1677,32 @@ ${f.content.slice(0, 1e3)}`
     this.state.tokenBudget.used += tokens;
   }
   /**
-   * AI-powered auto-scan, throttled by the trie.
-   * Uses context graph risk data to decide which files are worth spending tokens on.
+   * AI-powered watcher -- the primary detection system.
+   * 
+   * This is the single AI call that handles:
+   * 1. Code review (bugs, security, logic errors)
+   * 2. Goal violation detection (user-defined quality goals)
+   * 
+   * When goals are active, files with goal violations bypass priority scoring
+   * so violations are always caught. Throttled by cooldown + token budget.
    */
   async autoScanFiles(files) {
     if (!isAIAvailable()) return;
     if (this.state.autoScanInProgress) return;
     const now = Date.now();
-    if (now - this.state.lastAutoScan < _TrieWatchTool.AUTO_SCAN_COOLDOWN_MS) return;
+    if (now - this.state.lastAutoScan < this.aiWatcherCooldownMs) return;
+    try {
+      const projectPath = getWorkingDirectory(void 0, true);
+      const config = await getAutonomyConfig(projectPath);
+      const wc = config.aiWatcher;
+      if (!wc.enabled) return;
+      this.state.tokenBudget.hourlyLimit = wc.hourlyTokenLimit;
+      this.aiWatcherCooldownMs = wc.scanCooldownSec * 1e3;
+      this.cleanFileCooldownMs = wc.cleanFileCooldownSec * 1e3;
+      this.maxFilesPerScan = wc.maxFilesPerScan;
+      this.maxCharsPerFile = wc.maxCharsPerFile;
+    } catch {
+    }
     const remaining = this.getRemainingBudget();
     if (remaining < 500) return;
     this.state.autoScanInProgress = true;
@@ -1439,6 +1710,11 @@ ${f.content.slice(0, 1e3)}`
     try {
       const projectPath = getWorkingDirectory(void 0, true);
       const graph = new ContextGraph(projectPath);
+      const { getActiveGoals, recordGoalViolationCaught } = await import("./goal-validator-T5HEYBC5.js");
+      const { appendIssuesToLedger } = await import("./ledger-SR6OEBLO.js");
+      const activeGoals = await getActiveGoals(projectPath);
+      const hasGoals = activeGoals.length > 0;
+      if (this.isQuiet() && !hasGoals) return;
       const scored = [];
       for (const file of files) {
         const relativePath = file.replace(projectPath + "/", "");
@@ -1451,13 +1727,15 @@ ${f.content.slice(0, 1e3)}`
       }
       if (scored.length === 0) return;
       scored.sort((a, b) => b.score - a.score);
-      const maxFiles = remaining > 2e4 ? 5 : remaining > 1e4 ? 3 : 1;
-      const toScan = scored.slice(0, maxFiles);
+      const budgetScale = remaining > 2e4 ? 1 : remaining > 1e4 ? 0.6 : 0.4;
+      const maxFiles = Math.max(1, Math.round(this.maxFilesPerScan * budgetScale));
+      const filesToScan = scored.slice(0, maxFiles);
+      const charLimit = Math.round(this.maxCharsPerFile * (remaining > 15e3 ? 1 : 0.5));
       const fileContents = await Promise.all(
-        toScan.map(async ({ file, relativePath }) => {
+        filesToScan.map(async ({ file, relativePath }) => {
           try {
             const content = await readFile3(file, "utf-8");
-            return { path: relativePath, content: content.slice(0, 3e3) };
+            return { path: relativePath, content: content.slice(0, charLimit) };
           } catch {
             return null;
           }
@@ -1471,22 +1749,37 @@ ${f.content.slice(0, 1e3)}`
 ${f.content}
 \`\`\``
       ).join("\n\n");
+      let goalsSection = "";
+      if (hasGoals) {
+        goalsSection = `
+USER-DEFINED GOALS (IMPORTANT - check EVERY file against ALL goals):
+${activeGoals.map((g, i) => `  ${i + 1}. "${g.description}"`).join("\n")}
+
+Goal violations are HIGH PRIORITY. If a file violates any goal, you MUST report it.
+`;
+      }
       const result = await runAIAnalysis({
-        systemPrompt: `You are a code reviewer. Analyze the changed files below for bugs, security issues, logic errors, or risky patterns.
+        systemPrompt: `You are a code quality watcher. You review code for two things:
 
-Reply ONLY with a JSON array of issues found. Each issue must have:
+1. CODE ISSUES: bugs, security vulnerabilities, logic errors, risky patterns
+2. GOAL VIOLATIONS: check every file against the user's quality goals
+${goalsSection}
+Reply ONLY with a JSON array. Each element must have:
 - "file": relative file path
 - "severity": "critical" | "major" | "minor"
-- "description": 1-sentence description of the problem
+- "description": 1-sentence description
+- "isGoalViolation": true if this violates a user goal, false otherwise
+- "goalIndex": 0-based index of the violated goal (only if isGoalViolation is true)
 
-If there are no issues, reply with an empty array: []
+Be thorough with goal checking. If a goal says "no emojis" and you see an emoji anywhere in the file, report it. If a goal says "no inline styles" and you see a style attribute, report it.
 
-Do NOT include markdown fences or commentary. Output ONLY the JSON array.`,
-        userPrompt: `Review these recently changed files:
+If no issues or violations found, reply with: []
+Output ONLY the JSON array, no markdown fences, no commentary.`,
+        userPrompt: `Review these changed files:
 
 ${filesBlock}`,
-        maxTokens: 1024,
-        temperature: 0.2
+        maxTokens: 2048,
+        temperature: 0.1
       });
       if (result.tokensUsed) {
         this.recordTokenUsage(result.tokensUsed.input + result.tokensUsed.output);
@@ -1501,14 +1794,46 @@ ${filesBlock}`,
         return;
       }
       const issuedFiles = new Set(issues.map((i) => i.file));
-      for (const { relativePath } of toScan) {
+      for (const { relativePath } of filesToScan) {
         if (!issuedFiles.has(relativePath)) {
           this.state.cleanFiles.set(relativePath, Date.now());
         }
       }
       if (issues.length === 0) return;
-      for (const issue of issues.slice(0, 5)) {
+      for (const issue of issues.slice(0, 10)) {
         const severity = issue.severity === "critical" ? "critical" : issue.severity === "major" ? "major" : "minor";
+        if (issue.isGoalViolation && issue.goalIndex != null && issue.goalIndex >= 0 && issue.goalIndex < activeGoals.length) {
+          const goal = activeGoals[issue.goalIndex];
+          const nudgeMsg = `Goal "${goal.description}" violated in ${issue.file}: ${issue.description}`;
+          const ledgerIssue = {
+            id: `goal-ai-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            hash: "",
+            file: issue.file,
+            line: void 0,
+            agent: "ai-watcher",
+            severity: severity === "critical" ? "critical" : severity === "major" ? "high" : "medium",
+            issue: nudgeMsg,
+            fix: "Review and fix",
+            category: "goal-violation",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            project: basename2(projectPath),
+            resolved: false,
+            resolvedAt: void 0
+          };
+          await appendIssuesToLedger([ledgerIssue], projectPath);
+          await recordGoalViolationCaught(goal, issue.file, projectPath);
+          getOutputManager().nudge(nudgeMsg, "warning", issue.file);
+          this.state.nudges.push({
+            file: basename2(issue.file),
+            message: nudgeMsg,
+            severity: "high",
+            timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false })
+          });
+          if (!isInteractiveMode()) {
+            console.error(`   [!] Goal violation: ${nudgeMsg}`);
+          }
+          continue;
+        }
         const incident = await graph.addNode("incident", {
           description: issue.description,
           severity,
@@ -1534,7 +1859,7 @@ ${filesBlock}`,
         this.state.totalIssuesFound++;
         if (severity !== "minor") {
           getOutputManager().nudge(
-            `[!] ${issue.description}`,
+            `${issue.description}`,
             severity === "critical" ? "critical" : "warning",
             issue.file,
             severity === "critical" ? void 0 : 15e3
@@ -1555,7 +1880,8 @@ ${filesBlock}`,
           questions: 0
         });
       }
-    } catch {
+    } catch (error) {
+      getOutputManager().log("warn", `AI watcher error: ${error}`);
     } finally {
       this.state.autoScanInProgress = false;
     }
@@ -1632,7 +1958,7 @@ Use \`trie_watch start\` to begin autonomous scanning.`
     ).join("\n");
     let agencyStatus = "";
     try {
-      const { getGuardian } = await import("./guardian-agent-XEYNG7RH.js");
+      const { getGuardian } = await import("./guardian-agent-EXP7APLC.js");
       const trieAgent = getGuardian(getWorkingDirectory(void 0, true));
       await trieAgent.initialize();
       const status = await trieAgent.getAgencyStatus();