make-laten 1.2.1 → 1.2.3

package/dist/cli/index.mjs

@@ -1672,36 +1672,424 @@ var GitStatusCompressor = class {
   }
 };
 
-// src/cli/commands/benchmark.ts
+// src/route/tool-router.ts
+var ToolRouter = class {
+  rules = [
+    {
+      matcher: (input) => input.type === "file",
+      compressor: "file-read",
+      confidence: 0.95,
+      reason: "File read detected"
+    },
+    {
+      matcher: (input) => input.type === "grep",
+      compressor: "grep",
+      confidence: 0.95,
+      reason: "Grep results detected"
+    },
+    {
+      matcher: (input) => input.type === "git-diff",
+      compressor: "git-diff",
+      confidence: 0.95,
+      reason: "Git diff detected"
+    }
+  ];
+  route(input) {
+    for (const rule of this.rules) {
+      if (rule.matcher(input)) {
+        return {
+          tool: "compress",
+          compressor: rule.compressor,
+          confidence: rule.confidence,
+          reason: rule.reason
+        };
+      }
+    }
+    return {
+      tool: "compress",
+      confidence: 0.1,
+      reason: "No matching route found"
+    };
+  }
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+};
+
+// src/route/strategy-router.ts
+var StrategyRouter = class {
+  thresholds = {
+    small: 500,
+    large: 5e3
+  };
+  select(context) {
+    if (context.userPreference) {
+      return {
+        strategy: context.userPreference,
+        reason: `User preference: ${context.userPreference}`,
+        savings: this.estimateSavings(context.userPreference)
+      };
+    }
+    const fileSize = context.fileSize || 0;
+    if (fileSize >= this.thresholds.large) {
+      return {
+        strategy: "aggressive",
+        reason: `large file (${fileSize} bytes)`,
+        savings: 0.6
+      };
+    }
+    if (fileSize <= this.thresholds.small) {
+      return {
+        strategy: "conservative",
+        reason: `small file (${fileSize} bytes)`,
+        savings: 0.2
+      };
+    }
+    return {
+      strategy: "balanced",
+      reason: `Medium file (${fileSize} bytes)`,
+      savings: 0.4
+    };
+  }
+  estimateSavings(strategy) {
+    switch (strategy) {
+      case "aggressive":
+        return 0.6;
+      case "balanced":
+        return 0.4;
+      case "conservative":
+        return 0.2;
+    }
+  }
+};
+
+// src/learn/pattern-miner.ts
 import fs4 from "fs";
 import path3 from "path";
+var DATA_FILE = path3.join(process.env.HOME || "~", ".make-laten", "patterns.json");
+var PatternMiner = class {
+  operations = [];
+  patterns = /* @__PURE__ */ new Map();
+  persistencePath;
+  lastPersist = 0;
+  constructor(options) {
+    this.persistencePath = options?.persistencePath || DATA_FILE;
+    this.loadFromDisk();
+  }
+  loadFromDisk() {
+    try {
+      if (fs4.existsSync(this.persistencePath)) {
+        const data = JSON.parse(fs4.readFileSync(this.persistencePath, "utf-8"));
+        if (Array.isArray(data.patterns)) {
+          for (const p of data.patterns) {
+            this.patterns.set(p.type, p);
+          }
+        }
+        if (Array.isArray(data.operations)) {
+          this.operations = data.operations.slice(-100);
+        }
+      }
+    } catch {
+    }
+  }
+  persistToDisk() {
+    const now = Date.now();
+    if (now - this.lastPersist < 5e3) return;
+    this.lastPersist = now;
+    try {
+      const dir = path3.dirname(this.persistencePath);
+      if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+      fs4.writeFileSync(this.persistencePath, JSON.stringify({
+        patterns: Array.from(this.patterns.values()),
+        operations: this.operations.slice(-100)
+      }, null, 2));
+    } catch {
+    }
+  }
+  record(operation) {
+    this.operations.push(operation);
+    if (this.operations.length > 100) this.operations.shift();
+    if (operation.success) {
+      this.updatePatterns(operation);
+    }
+    this.persistToDisk();
+  }
+  getPatterns() {
+    return Array.from(this.patterns.values());
+  }
+  getPatternsByType(type) {
+    return this.getPatterns().filter((p) => p.type === type);
+  }
+  updatePatterns(operation) {
+    const key = operation.type;
+    const existing = this.patterns.get(key);
+    if (existing) {
+      existing.count++;
+      existing.confidence = Math.min(0.99, existing.confidence + 0.05);
+    } else {
+      this.patterns.set(key, {
+        id: `p${this.patterns.size + 1}`,
+        type: operation.type,
+        pattern: JSON.stringify(operation.input),
+        confidence: 0.5,
+        count: 1
+      });
+    }
+  }
+};
+
+// src/learn/failure-learner.ts
+import fs5 from "fs";
+import path4 from "path";
+var DATA_FILE2 = path4.join(process.env.HOME || "~", ".make-laten", "failures.json");
+var FailureLearner = class {
+  failures = /* @__PURE__ */ new Map();
+  persistencePath;
+  lastPersist = 0;
+  constructor(options) {
+    this.persistencePath = options?.persistencePath || DATA_FILE2;
+    this.loadFromDisk();
+  }
+  loadFromDisk() {
+    try {
+      if (fs5.existsSync(this.persistencePath)) {
+        const data = JSON.parse(fs5.readFileSync(this.persistencePath, "utf-8"));
+        if (Array.isArray(data.failures)) {
+          for (const f of data.failures) {
+            this.failures.set(`${f.type}:${f.error}`, f);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  persistToDisk() {
+    const now = Date.now();
+    if (now - this.lastPersist < 5e3) return;
+    this.lastPersist = now;
+    try {
+      const dir = path4.dirname(this.persistencePath);
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(this.persistencePath, JSON.stringify({
+        failures: Array.from(this.failures.values())
+      }, null, 2));
+    } catch {
+    }
+  }
+  record(failure) {
+    const key = `${failure.type}:${failure.error}`;
+    const existing = this.failures.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      this.failures.set(key, {
+        id: `f${this.failures.size + 1}`,
+        ...failure,
+        timestamp: Date.now(),
+        count: 1
+      });
+    }
+    this.persistToDisk();
+  }
+  getFailures() {
+    return Array.from(this.failures.values());
+  }
+  getFailuresByType(type) {
+    return this.getFailures().filter((f) => f.type === type);
+  }
+  getSuggestions(type) {
+    const failures = Array.from(this.failures.values()).filter((f) => f.type === type);
+    const suggestions = [];
+    for (const failure of failures) {
+      if (failure.error.includes("not found")) {
+        suggestions.push("check if file exists before processing");
+      }
+      if (failure.error.includes("permission")) {
+        suggestions.push("verify file permissions");
+      }
+      if (failure.count > 2) {
+        suggestions.push(`recurring issue: ${failure.error}`);
+      }
+    }
+    return [...new Set(suggestions)];
+  }
+};
+
+// src/correct/auto-correct.ts
+import fs6 from "fs";
+import path5 from "path";
+var DEFAULT_RULES = [
+  // Common typos
+  { name: "typo-teh", description: "Common typo", pattern: "teh", replacement: "the" },
+  { name: "typo-adn", description: "Common typo", pattern: "adn", replacement: "and" },
+  { name: "typo-fo", description: "Common typo", pattern: " fo ", replacement: " of " },
+  { name: "typo-ot", description: "Common typo", pattern: " ot ", replacement: " to " },
+  { name: "typo-isnt", description: "Common typo", pattern: "isnt", replacement: "isn't" },
+  { name: "typo-dont", description: "Common typo", pattern: "dont", replacement: "don't" },
+  { name: "typo-cant", description: "Common typo", pattern: "cant", replacement: "can't" },
+  { name: "typo-wont", description: "Common typo", pattern: "wont", replacement: "won't" },
+  { name: "typo-youre", description: "Common typo", pattern: "youre", replacement: "you're" },
+  { name: "typo-its", description: "Common typo", pattern: "its a", replacement: "it's a" },
+  // Code patterns
+  { name: "code-console-log", description: "Remove console.log", pattern: /console\.log\([^)]*\);?\n?/g, replacement: "" },
+  { name: "code-debugger", description: "Remove debugger", pattern: /debugger;?\n?/g, replacement: "" },
+  { name: "code-var-let", description: "var to let", pattern: /\bvar\b/g, replacement: "let" },
+  // Markdown
+  { name: "md-double-space", description: "Double space to single", pattern: "  ", replacement: " " }
+];
+var DATA_FILE3 = path5.join(process.env.HOME || "~", ".make-laten", "corrections.json");
+var AutoCorrect = class {
+  rules;
+  corrections = [];
+  appliedCount = 0;
+  persistencePath;
+  constructor(options) {
+    this.persistencePath = options?.persistencePath || DATA_FILE3;
+    this.rules = [...DEFAULT_RULES];
+    this.loadPersistedRules();
+  }
+  loadPersistedRules() {
+    try {
+      if (fs6.existsSync(this.persistencePath)) {
+        const data = JSON.parse(fs6.readFileSync(this.persistencePath, "utf-8"));
+        if (Array.isArray(data.customRules)) {
+          this.rules.push(...data.customRules);
+        }
+      }
+    } catch {
+    }
+  }
+  persistRules() {
+    try {
+      const dir = path5.dirname(this.persistencePath);
+      if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+      const existing = this.loadExistingData();
+      existing.customRules = this.rules.filter((r) => !DEFAULT_RULES.includes(r));
+      fs6.writeFileSync(this.persistencePath, JSON.stringify(existing, null, 2));
+    } catch {
+    }
+  }
+  loadExistingData() {
+    try {
+      if (fs6.existsSync(this.persistencePath)) {
+        return JSON.parse(fs6.readFileSync(this.persistencePath, "utf-8"));
+      }
+    } catch {
+    }
+    return { customRules: [] };
+  }
+  addRule(rule) {
+    this.rules.push(rule);
+    this.persistRules();
+  }
+  getRules() {
+    return this.rules;
+  }
+  correct(input) {
+    let output = input;
+    let changed = false;
+    for (const rule of this.rules) {
+      if (typeof rule.pattern === "string") {
+        if (output.includes(rule.pattern)) {
+          output = output.split(rule.pattern).join(rule.replacement);
+          changed = true;
+        }
+      } else {
+        const matches = output.match(rule.pattern);
+        if (matches) {
+          output = output.replace(rule.pattern, rule.replacement);
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      this.recordCorrection(input, output, "auto");
+    }
+    return output;
+  }
+  getStats() {
+    return {
+      applied: this.appliedCount,
+      corrections: this.corrections
+    };
+  }
+  recordCorrection(original, corrected, ruleName) {
+    this.appliedCount++;
+    this.corrections.push({
+      id: `c${this.corrections.length + 1}`,
+      original,
+      corrected,
+      rule: ruleName,
+      confidence: 0.9
+    });
+  }
+};
+
+// src/cli/commands/benchmark.ts
+import fs7 from "fs";
+import path6 from "path";
 import { execSync } from "child_process";
+function countTokens(text) {
+  return Math.ceil(text.length / 4);
+}
 async function benchmark() {
-  const fileCompressor = new FileReadCompressor();
-  const diffCompressor = new GitDiffCompressor();
-  const statusCompressor = new GitStatusCompressor();
   const projectPath = process.cwd();
   console.log("");
-  console.log("  make-laten benchmark");
-  console.log("  ===================");
+  console.log("  make-laten benchmark (17 tools)");
+  console.log("  ================================");
   console.log("");
   const results = [];
-  const testFiles = ["src/index.ts", "package.json", "README.md", "src/mcp/server.ts"];
-  for (const file of testFiles) {
-    const full = path3.join(projectPath, file);
-    if (!fs4.existsSync(full)) continue;
-    const content = fs4.readFileSync(full, "utf-8");
-    const raw = Math.round(content.length / 4);
-    const result = await fileCompressor.compress({ content, filePath: file });
-    const compressed = Math.round(result.content.length / 4);
-    results.push({ name: `read ${file}`, raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
+  console.log("  Compress Layer");
+  console.log("  " + "\u2500".repeat(50));
+  const smallFile = path6.join(projectPath, "src/index.ts");
+  if (fs7.existsSync(smallFile)) {
+    const content = fs7.readFileSync(smallFile, "utf-8");
+    const raw = countTokens(content);
+    const compressor = new FileReadCompressor();
+    const result = await compressor.compress({ content, filePath: "src/index.ts" });
+    const compressed = countTokens(result.content);
+    results.push({ name: "read (small)", raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
+  }
+  const mediumFile = path6.join(projectPath, "src/mcp/server.ts");
+  if (fs7.existsSync(mediumFile)) {
+    const content = fs7.readFileSync(mediumFile, "utf-8");
+    const raw = countTokens(content);
+    const compressor = new FileReadCompressor();
+    const result = await compressor.compress({ content, filePath: "src/mcp/server.ts" });
+    const compressed = countTokens(result.content);
+    results.push({ name: "read (medium)", raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
+  }
+  const largeFile = path6.join(projectPath, "README.md");
+  if (fs7.existsSync(largeFile)) {
+    const content = fs7.readFileSync(largeFile, "utf-8");
+    const raw = countTokens(content);
+    const compressor = new FileReadCompressor();
+    const result = await compressor.compress({ content, filePath: "README.md" });
+    const compressed = countTokens(result.content);
+    results.push({ name: "read (large)", raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
+  }
+  try {
+    const grepResult = execSync('grep -rn "export" src/ 2>/dev/null | head -30', { cwd: projectPath, encoding: "utf-8" }).trim();
+    if (grepResult) {
+      const raw = countTokens(grepResult);
+      const matches = grepResult.split("\n").filter(Boolean).map((line) => {
+        const parts = line.split(":");
+        return { file: parts[0], line: parseInt(parts[1], 10) || 0, content: parts.slice(2).join(":").trim() };
+      });
+      const compressor = new GrepCompressor();
+      const result = await compressor.compress({ results: matches, pattern: "export", directory: "src/" });
+      const compressed = countTokens(result.content);
+      results.push({ name: "grep", raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
+    }
+  } catch {
   }
   try {
     const diff = execSync('git diff HEAD~1 2>/dev/null || echo ""', { cwd: projectPath, encoding: "utf-8" }).trim();
     if (diff) {
-      const raw = Math.round(diff.length / 4);
-      const result = await diffCompressor.compress({ diff });
-      const compressed = Math.round(result.content.length / 4);
+      const raw = countTokens(diff);
+      const compressor = new GitDiffCompressor();
+      const result = await compressor.compress({ diff });
+      const compressed = countTokens(result.content);
       results.push({ name: "git-diff", raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
     }
   } catch {
@@ -1709,23 +2097,108 @@ async function benchmark() {
   try {
     const status = execSync('git status --porcelain 2>/dev/null || echo ""', { cwd: projectPath, encoding: "utf-8" }).trim();
     if (status) {
-      const raw = Math.round(status.length / 4);
-      const result = await statusCompressor.compress({ status });
-      const compressed = Math.round(result.content.length / 4);
+      const raw = countTokens(status);
+      const compressor = new GitStatusCompressor();
+      const result = await compressor.compress({ status });
+      const compressed = countTokens(result.content);
       results.push({ name: "git-status", raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
     }
   } catch {
   }
-  console.log("  Command".padEnd(28) + "Raw".padEnd(10) + "Compressed".padEnd(12) + "Savings");
-  console.log("  " + "\u2500".repeat(60));
-  for (const r of results) {
-    console.log(`  ${r.name}`.padEnd(28) + `${r.raw}`.padEnd(10) + `${r.compressed}`.padEnd(12) + `${r.savings}%`);
+  console.log("");
+  console.log("  Route Layer");
+  console.log("  " + "\u2500".repeat(50));
+  const router = new ToolRouter();
+  const strategyRouter = new StrategyRouter();
+  const routeTests = [
+    { type: "file", content: "test" },
+    { type: "grep", content: "test" },
+    { type: "git-diff", content: "test" }
+  ];
+  for (const test of routeTests) {
+    const route = router.route(test);
+    console.log(`    route(${test.type}) \u2192 ${route.compressor || "none"} (${Math.round(route.confidence * 100)}%)`);
+  }
+  const strategies = [
+    { fileSize: 100, pref: void 0 },
+    { fileSize: 1e3, pref: void 0 },
+    { fileSize: 1e4, pref: void 0 },
+    { fileSize: 0, pref: "aggressive" }
+  ];
+  for (const s of strategies) {
+    const strategy = strategyRouter.select({ fileSize: s.fileSize, userPreference: s.pref });
+    console.log(`    strategy(${s.fileSize || s.pref}) \u2192 ${strategy.strategy} (savings: ${Math.round(strategy.savings * 100)}%)`);
+  }
+  console.log("");
+  console.log("  Cache Layer");
+  console.log("  " + "\u2500".repeat(50));
+  const cache = new SessionCache();
+  cache.set("test:key1", { content: "value1", metadata: {} });
+  cache.set("test:key2", { content: "value2", metadata: {} });
+  cache.get("test:key1");
+  cache.get("test:key1");
+  cache.get("test:key2");
+  cache.get("test:miss");
+  const cacheStats = cache.stats();
+  console.log(`    L1 Session: ${cacheStats.size} entries, ${cacheStats.hits} hits, ${cacheStats.misses} misses, ${Math.round(cacheStats.hitRate * 100)}% hit rate`);
+  console.log("");
+  console.log("  Learn Layer");
+  console.log("  " + "\u2500".repeat(50));
+  const miner = new PatternMiner();
+  miner.record({ type: "file-read", input: { file: "a.ts" }, success: true });
+  miner.record({ type: "file-read", input: { file: "b.ts" }, success: true });
+  miner.record({ type: "grep", input: { pattern: "test" }, success: true });
+  miner.record({ type: "git-diff", input: {}, success: true });
+  const learner = new FailureLearner();
+  learner.record({ type: "file-read", error: "File not found", success: false });
+  learner.record({ type: "grep", error: "Permission denied", success: false });
+  const patterns = miner.getPatterns();
+  const failures = learner.getFailures();
+  console.log(`    Patterns: ${patterns.length} learned`);
+  for (const p of patterns.slice(0, 3)) {
+    console.log(`      - ${p.type}: confidence ${Math.round(p.confidence * 100)}%, count ${p.count}`);
+  }
+  console.log(`    Failures: ${failures.length} recorded`);
+  for (const f of failures.slice(0, 3)) {
+    const suggestions = learner.getSuggestions(f.type);
+    console.log(`      - ${f.type}: ${f.error} \u2192 ${suggestions[0] || "none"}`);
   }
+  console.log("");
+  console.log("  Correct Layer");
+  console.log("  " + "\u2500".repeat(50));
+  const correct = new AutoCorrect();
+  correct.addRule({ name: "typo", description: "Fix common typo", pattern: "teh", replacement: "the" });
+  correct.addRule({ name: "typo2", description: "Fix common typo", pattern: "adn", replacement: "and" });
+  const testText = "teh quick brown fox adn teh cat";
+  const corrected = correct.correct(testText);
+  const correctStats = correct.getStats();
+  console.log(`    Input:  "${testText}"`);
+  console.log(`    Output: "${corrected}"`);
+  console.log(`    Corrections applied: ${correctStats.applied}`);
+  console.log("");
+  console.log("  Web Layer");
+  console.log("  " + "\u2500".repeat(50));
+  const webRouter = new WebRouter();
+  const webStats = webRouter.getCacheStats();
+  console.log(`    Cache: ${webStats.fetchSize} fetch, ${webStats.searchSize} search`);
+  console.log(`    Backends: duckduckgo (default)`);
+  console.log(`    Features: semantic extraction, compression, caching`);
+  console.log("");
+  console.log("  Summary");
+  console.log("  " + "\u2500".repeat(50));
   const totalRaw = results.reduce((s, r) => s + r.raw, 0);
   const totalCompressed = results.reduce((s, r) => s + r.compressed, 0);
   const savings = Math.round((1 - totalCompressed / totalRaw) * 100);
+  console.log("  Command".padEnd(20) + "Raw".padEnd(10) + "Compressed".padEnd(12) + "Savings");
+  console.log("  " + "\u2500".repeat(50));
+  for (const r of results) {
+    console.log(`  ${r.name}`.padEnd(20) + `${r.raw}`.padEnd(10) + `${r.compressed}`.padEnd(12) + `${r.savings}%`);
+  }
+  console.log("  " + "\u2500".repeat(50));
+  console.log(`  ${"Total".padEnd(20)}${totalRaw}`.padEnd(10) + `${totalCompressed}`.padEnd(12) + `${savings}%`);
   console.log("");
-  console.log(`  Total: ${totalRaw} \u2192 ${totalCompressed} tokens (${savings}% saved)`);
+  console.log(`  17 tools exposed via MCP`);
+  console.log(`  4 layers: compress, route, cache, learn`);
   console.log("");
 }
 benchmark();