make-laten 1.2.2 → 1.2.3

package/dist/cli/index.mjs

@@ -1764,14 +1764,55 @@ var StrategyRouter = class {
 };
 
 // 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());
@@ -1798,8 +1839,43 @@ var PatternMiner = class {
 };
 
 // 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);
@@ -1813,6 +1889,7 @@ var FailureLearner = class {
         count: 1
       });
     }
+    this.persistToDisk();
   }
   getFailures() {
     return Array.from(this.failures.values());
@@ -1839,32 +1916,95 @@ var FailureLearner = class {
 };
 
 // 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 = [];
+  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);
-          this.recordCorrection(input, output, rule.name);
+          changed = true;
         }
       } else {
         const matches = output.match(rule.pattern);
         if (matches) {
           output = output.replace(rule.pattern, rule.replacement);
-          this.recordCorrection(input, output, rule.name);
+          changed = true;
         }
       }
     }
+    if (changed) {
+      this.recordCorrection(input, output, "auto");
+    }
     return output;
   }
   getStats() {
@@ -1886,8 +2026,8 @@ var AutoCorrect = class {
 };
 
 // src/cli/commands/benchmark.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs7 from "fs";
+import path6 from "path";
 import { execSync } from "child_process";
 function countTokens(text) {
   return Math.ceil(text.length / 4);
@@ -1901,27 +2041,27 @@ async function benchmark() {
   const results = [];
   console.log("  Compress Layer");
   console.log("  " + "\u2500".repeat(50));
-  const smallFile = path3.join(projectPath, "src/index.ts");
-  if (fs4.existsSync(smallFile)) {
-    const content = fs4.readFileSync(smallFile, "utf-8");
+  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 = path3.join(projectPath, "src/mcp/server.ts");
-  if (fs4.existsSync(mediumFile)) {
-    const content = fs4.readFileSync(mediumFile, "utf-8");
+  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 = path3.join(projectPath, "README.md");
-  if (fs4.existsSync(largeFile)) {
-    const content = fs4.readFileSync(largeFile, "utf-8");
+  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" });