@triedotdev/mcp 1.0.110 → 1.0.111

package/dist/cli/main.js

@@ -1,39 +1,34 @@
 #!/usr/bin/env node
 import {
-  IncidentIndex,
-  LearningEngine,
   LinearIngester,
   completeBootstrap,
+  getSkillCategories,
+  initProjectInfo,
+  initializeBootstrapFiles,
+  loadConfig,
+  loadContextState,
+  loadProjectInfo,
+  needsBootstrap,
+  projectInfoExists,
+  saveConfig
+} from "../chunk-TKMV7JKN.js";
+import {
+  IncidentIndex,
+  LearningEngine,
   exportToJson,
   formatAuditLog,
   formatFriendlyError,
   getAuditStatistics,
-  getAutonomyConfig,
   getRecentAuditLogs,
   getSkillAuditLogs,
-  getSkillCategories,
   getStagedChanges,
   getUncommittedChanges,
   handleCheckpointCommand,
   importFromJson,
-  initProjectInfo,
-  initializeBootstrapFiles,
-  loadConfig,
-  loadContextState,
-  loadProjectInfo,
-  needsBootstrap,
+  isTrieInitialized,
   perceiveCurrentChanges,
-  projectInfoExists,
-  reasonAboutChangesHumanReadable,
-  recordBypass,
-  saveConfig,
-  shouldAutoFix,
-  shouldBlockPush,
-  trackIssueOccurrence
-} from "../chunk-FLBK5ILJ.js";
-import {
-  isTrieInitialized
-} from "../chunk-HIKONDDO.js";
+  reasonAboutChangesHumanReadable
+} from "../chunk-QYOACM2C.js";
 import {
   ContextGraph,
   GotchaPredictor,
@@ -42,7 +37,7 @@ import {
   listTrackedProjects,
   searchGlobalPatterns,
   updateGlobalMemoryMd
-} from "../chunk-OTTR5JX4.js";
+} from "../chunk-6QR6QZIX.js";
 import "../chunk-IXO4G4D3.js";
 import {
   getDailyLogs,
@@ -65,7 +60,7 @@ import {
 } from "../chunk-DGUM43GV.js";
 
 // src/cli/main.ts
-import { resolve, join as join3, dirname } from "path";
+import { resolve, join as join4, dirname } from "path";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 
@@ -710,6 +705,274 @@ async function handleCheckCommand(args) {
   }
 }
 
+// src/utils/autonomy-config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+
+// src/types/autonomy.ts
+var DEFAULT_AUTONOMY_CONFIG = {
+  level: "proactive",
+  autoCheck: {
+    enabled: true,
+    threshold: 5,
+    onCritical: true,
+    cooldownMs: 3e4
+    // 30 seconds
+  },
+  autoFix: {
+    enabled: true,
+    askFirst: true,
+    // Always ask (human-in-the-loop)
+    categories: ["trivial", "safe"],
+    allowedFixTypes: [
+      "remove-console-log",
+      "remove-unused-import",
+      "add-missing-await",
+      "fix-typo"
+    ]
+  },
+  pushBlocking: {
+    enabled: true,
+    allowBypass: true,
+    blockOn: ["critical"],
+    bypassMethods: ["env", "flag", "confirm"],
+    logBypasses: true
+  },
+  progressiveEscalation: {
+    enabled: true,
+    thresholds: {
+      suggest: 1,
+      autoCheck: 3,
+      escalate: 5,
+      block: 10
+    },
+    windowMs: 24 * 60 * 60 * 1e3
+    // 24 hours
+  }
+};
+
+// src/utils/autonomy-config.ts
+import { createHash } from "crypto";
+async function loadAutonomyConfig(projectPath) {
+  const configPath = join(getTrieDirectory(projectPath), "config.json");
+  try {
+    if (!existsSync(configPath)) {
+      return { ...DEFAULT_AUTONOMY_CONFIG };
+    }
+    const content = await readFile(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return mergeWithDefaults(config.autonomy || {});
+  } catch (error) {
+    console.error("Failed to load autonomy config:", error);
+    return { ...DEFAULT_AUTONOMY_CONFIG };
+  }
+}
+function mergeWithDefaults(partial) {
+  return {
+    level: partial.level ?? DEFAULT_AUTONOMY_CONFIG.level,
+    autoCheck: {
+      ...DEFAULT_AUTONOMY_CONFIG.autoCheck,
+      ...partial.autoCheck || {}
+    },
+    autoFix: {
+      ...DEFAULT_AUTONOMY_CONFIG.autoFix,
+      ...partial.autoFix || {}
+    },
+    pushBlocking: {
+      ...DEFAULT_AUTONOMY_CONFIG.pushBlocking,
+      ...partial.pushBlocking || {}
+    },
+    progressiveEscalation: {
+      ...DEFAULT_AUTONOMY_CONFIG.progressiveEscalation,
+      ...partial.progressiveEscalation || {},
+      thresholds: {
+        ...DEFAULT_AUTONOMY_CONFIG.progressiveEscalation.thresholds,
+        ...partial.progressiveEscalation?.thresholds || {}
+      }
+    }
+  };
+}
+var occurrenceCache = /* @__PURE__ */ new Map();
+async function getOccurrences(projectPath) {
+  if (occurrenceCache.has(projectPath)) {
+    return occurrenceCache.get(projectPath);
+  }
+  const occurrencesPath = join(getTrieDirectory(projectPath), "memory", "occurrences.json");
+  const occurrences = /* @__PURE__ */ new Map();
+  try {
+    if (existsSync(occurrencesPath)) {
+      const content = await readFile(occurrencesPath, "utf-8");
+      const data = JSON.parse(content);
+      for (const [hash, occ] of Object.entries(data)) {
+        occurrences.set(hash, occ);
+      }
+    }
+  } catch {
+  }
+  occurrenceCache.set(projectPath, occurrences);
+  return occurrences;
+}
+async function saveOccurrences(projectPath) {
+  const occurrences = occurrenceCache.get(projectPath);
+  if (!occurrences) return;
+  const occurrencesPath = join(getTrieDirectory(projectPath), "memory", "occurrences.json");
+  const memoryDir = join(getTrieDirectory(projectPath), "memory");
+  try {
+    if (!existsSync(memoryDir)) {
+      await mkdir(memoryDir, { recursive: true });
+    }
+    const data = {};
+    for (const [hash, occ] of occurrences.entries()) {
+      data[hash] = occ;
+    }
+    await writeFile(occurrencesPath, JSON.stringify(data, null, 2));
+  } catch (error) {
+    console.error("Failed to save occurrences:", error);
+  }
+}
+function createIssueHash(file, line, issueType) {
+  const input = `${file}:${line || 0}:${issueType}`;
+  return createHash("md5").update(input).digest("hex").slice(0, 12);
+}
+async function trackIssueOccurrence(projectPath, file, line, issueType, config) {
+  const occurrences = await getOccurrences(projectPath);
+  const hash = createIssueHash(file, line, issueType);
+  const now = Date.now();
+  let occurrence = occurrences.get(hash);
+  if (occurrence) {
+    const windowMs = config.progressiveEscalation.windowMs;
+    if (now - occurrence.firstSeen > windowMs) {
+      occurrence = {
+        hash,
+        firstSeen: now,
+        lastSeen: now,
+        count: 1,
+        escalationLevel: "suggest",
+        notified: false,
+        bypassed: false,
+        bypassHistory: occurrence.bypassHistory
+        // Keep bypass history
+      };
+    } else {
+      occurrence.lastSeen = now;
+      occurrence.count++;
+      const thresholds = config.progressiveEscalation.thresholds;
+      if (occurrence.count >= thresholds.block) {
+        occurrence.escalationLevel = "block";
+      } else if (occurrence.count >= thresholds.escalate) {
+        occurrence.escalationLevel = "escalate";
+      } else if (occurrence.count >= thresholds.autoCheck) {
+        occurrence.escalationLevel = "autoCheck";
+      }
+    }
+  } else {
+    occurrence = {
+      hash,
+      firstSeen: now,
+      lastSeen: now,
+      count: 1,
+      escalationLevel: "suggest",
+      notified: false,
+      bypassed: false,
+      bypassHistory: []
+    };
+  }
+  occurrences.set(hash, occurrence);
+  await saveOccurrences(projectPath);
+  return occurrence;
+}
+async function recordBypass(projectPath, file, line, issueType, method, reason) {
+  const occurrences = await getOccurrences(projectPath);
+  const hash = createIssueHash(file, line, issueType);
+  const occurrence = occurrences.get(hash);
+  if (occurrence) {
+    occurrence.bypassed = true;
+    occurrence.bypassHistory.push({
+      timestamp: Date.now(),
+      method,
+      ...reason !== void 0 ? { reason } : {}
+    });
+    await saveOccurrences(projectPath);
+  }
+}
+function shouldAutoFix(fix, config) {
+  if (!config.autoFix.enabled) {
+    return false;
+  }
+  const allowedCategories = config.autoFix.categories;
+  if (!allowedCategories.includes(fix.category) && !allowedCategories.includes("all")) {
+    return false;
+  }
+  if (config.autoFix.allowedFixTypes.length > 0 && !config.autoFix.allowedFixTypes.includes(fix.type)) {
+    return false;
+  }
+  if (fix.confidence < 0.9) {
+    return false;
+  }
+  return true;
+}
+function shouldBlockPush(issues, config) {
+  if (!config.pushBlocking.enabled) {
+    return {
+      blocked: false,
+      blockingIssues: [],
+      bypassed: false
+    };
+  }
+  const blockingIssues = issues.filter(
+    (issue) => config.pushBlocking.blockOn.includes(issue.severity)
+  );
+  if (blockingIssues.length === 0) {
+    return {
+      blocked: false,
+      blockingIssues: [],
+      bypassed: false
+    };
+  }
+  const envBypass = process.env.TRIE_BYPASS === "1" || process.env.TRIE_BYPASS === "true";
+  if (envBypass && config.pushBlocking.allowBypass) {
+    return {
+      blocked: false,
+      blockingIssues,
+      bypassed: true,
+      bypassMethod: "env"
+    };
+  }
+  const bypassInstructions = buildBypassInstructions(config);
+  return {
+    blocked: true,
+    reason: `${blockingIssues.length} ${blockingIssues[0]?.severity || "critical"} issue(s) must be fixed before pushing`,
+    blockingIssues,
+    bypassInstructions,
+    bypassed: false
+  };
+}
+function buildBypassInstructions(config) {
+  const instructions = [];
+  if (config.pushBlocking.bypassMethods.includes("env")) {
+    instructions.push("\u2022 Set TRIE_BYPASS=1 to bypass: TRIE_BYPASS=1 git push");
+  }
+  if (config.pushBlocking.bypassMethods.includes("flag")) {
+    instructions.push("\u2022 Use --no-verify flag: git push --no-verify");
+  }
+  if (config.pushBlocking.bypassMethods.includes("confirm")) {
+    instructions.push("\u2022 Run: trie bypass --confirm to bypass this push");
+  }
+  return instructions.join("\n");
+}
+var configCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 6e4;
+async function getAutonomyConfig(projectPath) {
+  const cached = configCache.get(projectPath);
+  if (cached && Date.now() - cached.loadedAt < CACHE_TTL) {
+    return cached.config;
+  }
+  const config = await loadAutonomyConfig(projectPath);
+  configCache.set(projectPath, { config, loadedAt: Date.now() });
+  return config;
+}
+
 // src/cli/pre-push.ts
 import pc from "picocolors";
 function parseArgs2(args) {
@@ -843,8 +1106,8 @@ function collectIssuesForBlocking(reasoning) {
 }
 
 // src/cli/auto-fix.ts
-import { readFile, writeFile } from "fs/promises";
-import { existsSync } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
 import { createInterface } from "readline";
 import pc2 from "picocolors";
 function detectAutoFixes(issues) {
@@ -920,11 +1183,11 @@ function displayFixPreview(fix, index, total) {
 }
 async function applyFix(fix) {
   try {
-    if (!existsSync(fix.file)) {
+    if (!existsSync2(fix.file)) {
       console.error(pc2.red(`File not found: ${fix.file}`));
       return false;
     }
-    const content = await readFile(fix.file, "utf-8");
+    const content = await readFile2(fix.file, "utf-8");
     const lines = content.split("\n");
     if (fix.line === void 0 || fix.line < 1 || fix.line > lines.length) {
       console.error(pc2.red(`Invalid line number: ${fix.line}`));
@@ -943,7 +1206,7 @@ async function applyFix(fix) {
       console.error(pc2.red(`Unknown fix type: ${fix.type}`));
       return false;
     }
-    await writeFile(fix.file, newContent);
+    await writeFile2(fix.file, newContent);
     console.error(pc2.green(`\u2713 Applied fix to ${fix.file}:${fix.line}`));
     if (originalLine) {
       console.error(pc2.dim(`  Removed: ${originalLine.trim().slice(0, 60)}...`));
@@ -957,11 +1220,11 @@ async function applyFix(fix) {
 async function loadFixContent(fixes) {
   const enrichedFixes = [];
   for (const fix of fixes) {
-    if (!fix.line || !existsSync(fix.file)) {
+    if (!fix.line || !existsSync2(fix.file)) {
       continue;
     }
     try {
-      const content = await readFile(fix.file, "utf-8");
+      const content = await readFile2(fix.file, "utf-8");
       const lines = content.split("\n");
       const originalLine = lines[fix.line - 1];
       if (originalLine) {
@@ -1625,8 +1888,8 @@ async function handleQuietCommand() {
 }
 
 // src/cli/ci.ts
-import { writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
-import { join } from "path";
+import { writeFileSync, existsSync as existsSync3, mkdirSync } from "fs";
+import { join as join2 } from "path";
 import pc4 from "picocolors";
 var WORKFLOW_TEMPLATE = `# Trie Security Scan with Memory Persistence
 # Generated by: trie ci
@@ -1717,8 +1980,8 @@ jobs:
 `;
 function handleCISetupCommand(args) {
   const workDir = getWorkingDirectory(void 0, true);
-  const workflowsDir = join(workDir, ".github", "workflows");
-  const workflowPath = join(workflowsDir, "trie-scan.yml");
+  const workflowsDir = join2(workDir, ".github", "workflows");
+  const workflowPath = join2(workflowsDir, "trie-scan.yml");
   const isMinimal = args.includes("--minimal") || args.includes("-m");
   const isDryRun = args.includes("--dry-run") || args.includes("-n");
   const showHelp3 = args.includes("--help") || args.includes("-h");
@@ -1767,13 +2030,13 @@ ${pc4.bold("REQUIRED SECRETS:")}
     console.log(pc4.dim("\nRun without --dry-run to create the file."));
     return;
   }
-  if (existsSync2(workflowPath)) {
+  if (existsSync3(workflowPath)) {
     console.log(pc4.yellow("Workflow already exists: .github/workflows/trie-scan.yml"));
     console.log(pc4.dim("   Run with --dry-run to preview what would be written."));
     console.log(pc4.dim("   Delete the existing file to regenerate."));
     return;
   }
-  if (!existsSync2(workflowsDir)) {
+  if (!existsSync3(workflowsDir)) {
     mkdirSync(workflowsDir, { recursive: true });
   }
   writeFileSync(workflowPath, template);
@@ -2019,21 +2282,21 @@ async function handleLearnCommand(args) {
 }
 
 // src/cli/patterns.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
 import { basename as basename2 } from "path";
 import picocolors3 from "picocolors";
 
 // src/patterns/saved-patterns.ts
-import { createHash } from "crypto";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join2, basename } from "path";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join3, basename } from "path";
 async function loadSavedPatterns(workDir) {
-  const patternsPath = join2(getTrieDirectory(workDir), "saved-patterns.json");
+  const patternsPath = join3(getTrieDirectory(workDir), "saved-patterns.json");
   try {
-    if (existsSync3(patternsPath)) {
-      const content = await readFile2(patternsPath, "utf-8");
+    if (existsSync4(patternsPath)) {
+      const content = await readFile3(patternsPath, "utf-8");
       return JSON.parse(content);
     }
   } catch {
@@ -2041,10 +2304,10 @@ async function loadSavedPatterns(workDir) {
   return [];
 }
 async function savePatternsToProject(patterns, workDir) {
-  const { mkdir } = await import("fs/promises");
-  const patternsPath = join2(getTrieDirectory(workDir), "saved-patterns.json");
-  await mkdir(getTrieDirectory(workDir), { recursive: true });
-  await writeFile2(patternsPath, JSON.stringify(patterns, null, 2));
+  const { mkdir: mkdir2 } = await import("fs/promises");
+  const patternsPath = join3(getTrieDirectory(workDir), "saved-patterns.json");
+  await mkdir2(getTrieDirectory(workDir), { recursive: true });
+  await writeFile3(patternsPath, JSON.stringify(patterns, null, 2));
 }
 async function savePatternToProject(pattern, workDir) {
   const patterns = await loadSavedPatterns(workDir);
@@ -2079,14 +2342,14 @@ function detectPatternType(target, workDir) {
   if (scoutNames.includes(target.toLowerCase())) {
     return "detection-rule";
   }
-  const fullPath = join2(workDir, target);
-  if (existsSync3(fullPath) || target.includes("/") || target.includes("*") || target.endsWith(".ts") || target.endsWith(".js")) {
+  const fullPath = join3(workDir, target);
+  if (existsSync4(fullPath) || target.includes("/") || target.includes("*") || target.endsWith(".ts") || target.endsWith(".js")) {
     return "file-structure";
   }
   return "code-pattern";
 }
 function generatePatternId(target, type) {
-  const hash = createHash("sha256").update(`${type}:${target}`).digest("hex").slice(0, 12);
+  const hash = createHash2("sha256").update(`${type}:${target}`).digest("hex").slice(0, 12);
   return `${type}-${hash}`;
 }
 async function createSavedPattern(target, note, workDir) {
@@ -2238,7 +2501,7 @@ async function handleExportPatterns(args, workDir) {
     exportedFrom: basename2(workDir),
     patterns
   };
-  await writeFile3(outputPath, JSON.stringify(exportData, null, 2));
+  await writeFile4(outputPath, JSON.stringify(exportData, null, 2));
   console.log(picocolors3.green(`\u2713 Exported ${patterns.length} patterns to ${outputPath}`));
   console.log(picocolors3.dim(`  Import to another project with: trie patterns import ${outputPath}`));
 }
@@ -2248,11 +2511,11 @@ async function handleImportPatterns(args, workDir) {
     console.error(picocolors3.red("Usage: trie patterns import <path-to-patterns.json>"));
     process.exit(1);
   }
-  if (!existsSync4(inputPath)) {
+  if (!existsSync5(inputPath)) {
     console.error(picocolors3.red(`File not found: ${inputPath}`));
     process.exit(1);
   }
-  const content = await readFile3(inputPath, "utf-8");
+  const content = await readFile4(inputPath, "utf-8");
   const importData = JSON.parse(content);
   if (!importData.patterns || !Array.isArray(importData.patterns)) {
     console.error(picocolors3.red("Invalid pattern file format."));
@@ -2581,7 +2844,7 @@ Next steps:
   }
   if (subcommand === "edit") {
     const editor = process.env.EDITOR || process.env.VISUAL || "nano";
-    const projectPath = join3(getTrieDirectory(workDir), "PROJECT.md");
+    const projectPath = join4(getTrieDirectory(workDir), "PROJECT.md");
     if (!projectInfoExists(workDir)) {
       console.log("No PROJECT.md found. Creating one first...");
       await initProjectInfo(workDir);
@@ -2627,7 +2890,7 @@ This info is available via trie://project MCP resource.
 \u2551                    \u{1F4CB} Project Information                        \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
-Path: ${join3(getTrieDirectory(workDir), "PROJECT.md")}
+Path: ${join4(getTrieDirectory(workDir), "PROJECT.md")}
 
 ${"-".repeat(68)}
 `);