make-laten 1.2.2 → 1.2.3

package/dist/mcp/server.mjs

@@ -475,14 +475,55 @@ var StrategyRouter = class {
 };
 
 // src/learn/pattern-miner.ts
+import fs from "fs";
+import path from "path";
+var DATA_FILE = path.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 (fs.existsSync(this.persistencePath)) {
+        const data = JSON.parse(fs.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 = path.dirname(this.persistencePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.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());
@@ -509,8 +550,43 @@ var PatternMiner = class {
 };
 
 // src/learn/failure-learner.ts
+import fs2 from "fs";
+import path2 from "path";
+var DATA_FILE2 = path2.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 (fs2.existsSync(this.persistencePath)) {
+        const data = JSON.parse(fs2.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 = path2.dirname(this.persistencePath);
+      if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+      fs2.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);
@@ -524,6 +600,7 @@ var FailureLearner = class {
         count: 1
       });
     }
+    this.persistToDisk();
   }
   getFailures() {
     return Array.from(this.failures.values());
@@ -550,32 +627,95 @@ var FailureLearner = class {
 };
 
 // src/correct/auto-correct.ts
+import fs3 from "fs";
+import path3 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 = path3.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 (fs3.existsSync(this.persistencePath)) {
+        const data = JSON.parse(fs3.readFileSync(this.persistencePath, "utf-8"));
+        if (Array.isArray(data.customRules)) {
+          this.rules.push(...data.customRules);
+        }
+      }
+    } catch {
+    }
+  }
+  persistRules() {
+    try {
+      const dir = path3.dirname(this.persistencePath);
+      if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
+      const existing = this.loadExistingData();
+      existing.customRules = this.rules.filter((r) => !DEFAULT_RULES.includes(r));
+      fs3.writeFileSync(this.persistencePath, JSON.stringify(existing, null, 2));
+    } catch {
+    }
+  }
+  loadExistingData() {
+    try {
+      if (fs3.existsSync(this.persistencePath)) {
+        return JSON.parse(fs3.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() {
@@ -959,7 +1099,7 @@ function extractSimpleTitle(html) {
 // src/mcp/server.ts
 import { exec } from "child_process";
 import { promisify } from "util";
-import fs from "fs/promises";
+import fs4 from "fs/promises";
 var execAsync = promisify(exec);
 var sessionCache = new SessionCache();
 var toolRouter = new ToolRouter();
@@ -1069,17 +1209,17 @@ var TOOLS = [
   // Learn Layer
   {
     name: "make-laten-patterns",
-    description: "Get learned patterns from usage",
+    description: "Get learned patterns from usage (persisted across sessions)",
     inputSchema: { type: "object", properties: {} }
   },
   {
     name: "make-laten-failures",
-    description: "Get failure records and suggestions",
+    description: "Get failure records and suggestions (persisted across sessions)",
     inputSchema: { type: "object", properties: {} }
   },
   {
     name: "make-laten-suggestions",
-    description: "Get suggestions based on learned patterns",
+    description: "Get suggestions based on learned patterns and failures",
     inputSchema: {
       type: "object",
       properties: {
@@ -1090,7 +1230,7 @@ var TOOLS = [
   // Correct Layer
   {
     name: "make-laten-correct",
-    description: "Apply auto-corrections to text",
+    description: "Apply auto-corrections to text (11 built-in rules + custom rules)",
     inputSchema: {
       type: "object",
       properties: {
@@ -1151,7 +1291,7 @@ function detectLanguage(filePath) {
   return map[ext] || "text";
 }
 async function handleRead(params) {
-  const content = await fs.readFile(params.file_path, "utf-8");
+  const content = await fs4.readFile(params.file_path, "utf-8");
   const compressor = new FileReadCompressor();
   const result = await compressor.compress({
     content,
@@ -1293,7 +1433,7 @@ async function handleLine(line) {
       sendResponse(request.id, {
         protocolVersion: "2024-11-05",
         capabilities: { tools: {} },
-        serverInfo: { name: "make-laten", version: "1.2.0" }
+        serverInfo: { name: "make-laten", version: "1.3.0" }
       });
     } else if (request.method === "notifications/initialized") {
     } else if (request.method === "tools/list") {