make-laten 1.1.1 → 1.2.1

package/dist/mcp/server.mjs

@@ -29,29 +29,145 @@ function isKnownPattern(content) {
   return patterns.some((p) => p.test(content));
 }
 
+// src/compress/strip.ts
+function stripImports(content) {
+  return content.replace(/^import\s+[\s\S]*?from\s+['"][^'"]+['"]\s*;?\s*$/gm, "").replace(/^import\s+['"][^'"]+['"]\s*;?\s*$/gm, "").replace(/^import\s+\{[^}]*\}\s+from\s+['"][^'"]+['"]\s*;?\s*$/gm, "").split("\n").filter((l) => l.trim() !== "").join("\n");
+}
+function stripComments(content) {
+  let result = content.replace(/(?<!["'`])\/\/.*$/gm, "");
+  result = result.replace(/\/\*[\s\S]*?\*\//g, "");
+  return result.split("\n").filter((l) => l.trim() !== "").join("\n");
+}
+function stripBlankLines(content) {
+  return content.replace(/\n{3,}/g, "\n\n");
+}
+function stripWhitespace(content) {
+  return content.replace(/[ \t]+$/gm, "");
+}
+function stripAll(content) {
+  let result = content;
+  result = stripImports(result);
+  result = stripComments(result);
+  result = stripBlankLines(result);
+  result = stripWhitespace(result);
+  return result.trim();
+}
+
+// src/compress/structure.ts
+function extractExports(content) {
+  const lines = content.split("\n");
+  const exports = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^export\s+(default\s+)?/.test(trimmed)) {
+      if (trimmed.includes("{") && !trimmed.includes("}")) {
+        exports.push(trimmed.replace(/\{[\s\S]*$/, "{ ... }"));
+      } else {
+        exports.push(trimmed);
+      }
+    }
+  }
+  return exports.join("\n");
+}
+function extractClassMethods(content) {
+  const classRegex = /class\s+\w+[^{]*\{([\s\S]*?)\n\}/g;
+  const methods = [];
+  let match;
+  while ((match = classRegex.exec(content)) !== null) {
+    const classBody = match[1];
+    const methodRegex = /(^\s*(?:public|private|protected|static|async|abstract|\s)*\w+\s*\([^)]*\)(?:\s*:\s*[^{]+)?)\s*\{/gm;
+    let methodMatch;
+    while ((methodMatch = methodRegex.exec(classBody)) !== null) {
+      methods.push(methodMatch[1].trim());
+    }
+  }
+  return methods.join("\n");
+}
+function extractFunctionSignatures(content) {
+  const funcRegex = /(export\s+)?(async\s+)?function\s+\w+\s*\([^)]*\)(?:\s*:\s*[^{]+)?\s*\{/g;
+  const signatures = [];
+  let match;
+  while ((match = funcRegex.exec(content)) !== null) {
+    signatures.push(match[0].replace(/\{$/, ""));
+  }
+  return signatures.join("\n");
+}
+function extractTypeDefinitions(content) {
+  const typeRegex = /(export\s+)?(interface|type)\s+\w+[^{]*\{[^}]*\}|(export\s+)?type\s+\w+\s*=[^;]+;?/g;
+  const types = [];
+  let match;
+  while ((match = typeRegex.exec(content)) !== null) {
+    types.push(match[0].trim());
+  }
+  return types.join("\n");
+}
+
+// src/compress/truncate.ts
+function smartTruncate(content, maxTokens) {
+  const lines = content.split("\n");
+  const estimatedTokens = Math.ceil(content.length / 4);
+  if (estimatedTokens <= maxTokens) return content;
+  const targetLines = Math.round(maxTokens * 4 / (content.length / lines.length));
+  const headerLines = Math.floor(targetLines * 0.3);
+  const footerLines = Math.floor(targetLines * 0.3);
+  const omitted = lines.length - headerLines - footerLines;
+  const header = lines.slice(0, headerLines);
+  const footer = lines.slice(-footerLines);
+  return [...header, `
+... [${omitted} lines omitted] ...
+`, ...footer].join("\n");
+}
+
 // src/compress/file-read.ts
 var FileReadCompressor = class {
   async compress(input) {
     const { content, filePath, language } = input;
-    const signatures = this.extractSignatures(content, language);
-    const exports = this.extractExports(content);
-    const lines = [
+    const lines = content.split("\n").length;
+    const tokens = Math.ceil(content.length / 4);
+    if (tokens < 200) {
+      return {
+        content,
+        original: content,
+        confidence: 1,
+        metadata: {
+          strategy: "passthrough",
+          originalLines: lines,
+          compressedLines: lines,
+          savings: 0
+        }
+      };
+    }
+    const stripped = stripAll(content);
+    const exports = extractExports(stripped);
+    const classes = extractClassMethods(stripped);
+    const functions = extractFunctionSignatures(stripped);
+    const types = extractTypeDefinitions(stripped);
+    const sections = [
       `// ${filePath} (${content.split("\n").length} lines)`,
       "",
-      ...signatures,
-      "",
       "// Exports:",
-      ...exports
-    ];
-    const compressed = lines.join("\n");
+      exports,
+      "",
+      "// Classes:",
+      classes,
+      "",
+      "// Functions:",
+      functions,
+      "",
+      "// Types:",
+      types
+    ].filter((l) => l !== "" && !l.endsWith(":"));
+    let compressed = sections.join("\n");
+    const maxTokens = 2e3;
+    compressed = smartTruncate(compressed, maxTokens);
     return {
       content: compressed,
       original: content,
       confidence: calculateConfidence(content, compressed),
       metadata: {
-        strategy: "signatures",
+        strategy: "hybrid",
         originalLines: content.split("\n").length,
-        compressedLines: lines.length,
+        compressedLines: compressed.split("\n").length,
         savings: 1 - compressed.length / content.length
       }
     };
@@ -59,32 +175,6 @@ var FileReadCompressor = class {
   async decompress(compressed) {
     return compressed.original;
   }
-  extractSignatures(content, language) {
-    const signatures = [];
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (/^(export\s+)?(async\s+)?function\s+\w+/.test(trimmed)) {
-        signatures.push(trimmed.replace(/\{[\s\S]*$/, "{ ... }"));
-      }
-      if (/^(export\s+)?class\s+\w+/.test(trimmed)) {
-        signatures.push(trimmed);
-      }
-      if (/^(export\s+)?(type|interface)\s+\w+/.test(trimmed)) {
-        signatures.push(trimmed);
-      }
-    }
-    return signatures;
-  }
-  extractExports(content) {
-    const exports = [];
-    const exportRegex = /export\s+(default\s+)?(function|class|const|let|var|type|interface)\s+(\w+)/g;
-    let match;
-    while ((match = exportRegex.exec(content)) !== null) {
-      exports.push(`  - ${match[3]} (${match[2]})`);
-    }
-    return exports;
-  }
 };
 
 // src/compress/grep.ts
@@ -141,18 +231,21 @@ var GrepCompressor = class {
 var GitDiffCompressor = class {
   async compress(input) {
     const { diff } = input;
-    const hunks = this.parseDiff(diff);
-    const condensed = hunks.map((hunk) => ({
-      file: hunk.file,
-      changes: this.condenseHunk(hunk),
-      stats: { additions: hunk.additions, deletions: hunk.deletions }
-    }));
+    const files = this.parseDiff(diff);
     const lines = [];
-    for (const hunk of condensed) {
-      if (hunk.changes.length > 0) {
-        lines.push(`${hunk.file} (+${hunk.stats.additions} -${hunk.stats.deletions})`);
-        lines.push(...hunk.changes);
+    const totalAdd = files.reduce((s, f) => s + f.additions, 0);
+    const totalDel = files.reduce((s, f) => s + f.deletions, 0);
+    lines.push(`# ${files.length} files changed: +${totalAdd} -${totalDel}`);
+    lines.push("");
+    for (const file of files) {
+      lines.push(`${file.path} (+${file.additions} -${file.deletions})`);
+      const changes = file.lines.filter((l) => l.type === "add" || l.type === "del").map((l) => `${l.type === "add" ? "+" : "-"}${l.content}`);
+      const limited = changes.slice(0, 20);
+      lines.push(...limited);
+      if (changes.length > 20) {
+        lines.push(`... [${changes.length - 20} more changes]`);
       }
+      lines.push("");
     }
     const compressed = lines.join("\n");
     return {
@@ -161,7 +254,7 @@ var GitDiffCompressor = class {
       confidence: calculateConfidence(diff, compressed),
       metadata: {
         strategy: "condensed",
-        filesChanged: condensed.length,
+        filesChanged: files.length,
         savings: 1 - compressed.length / diff.length
       }
     };
@@ -170,46 +263,716 @@ var GitDiffCompressor = class {
     return compressed.original;
   }
   parseDiff(diff) {
-    const hunks = [];
+    const files = [];
     const lines = diff.split("\n");
-    let currentHunk = null;
+    let current = null;
     for (const line of lines) {
       if (line.startsWith("diff --git")) {
-        if (currentHunk) hunks.push(currentHunk);
-        const fileMatch = line.match(/b\/(.+)/);
-        currentHunk = {
-          file: fileMatch?.[1] || "unknown",
-          lines: [],
+        if (current) files.push(current);
+        const match = line.match(/b\/(.+)/);
+        current = {
+          path: match?.[1] || "unknown",
           additions: 0,
-          deletions: 0
+          deletions: 0,
+          lines: []
         };
-      } else if (currentHunk) {
+      } else if (current) {
         if (line.startsWith("+")) {
-          currentHunk.additions++;
-          currentHunk.lines.push({ type: "addition", content: line.slice(1) });
+          current.additions++;
+          current.lines.push({ type: "add", content: line.slice(1) });
         } else if (line.startsWith("-")) {
-          currentHunk.deletions++;
-          currentHunk.lines.push({ type: "deletion", content: line.slice(1) });
+          current.deletions++;
+          current.lines.push({ type: "del", content: line.slice(1) });
         }
       }
     }
-    if (currentHunk) hunks.push(currentHunk);
-    return hunks;
+    if (current) files.push(current);
+    return files;
+  }
+};
+
+// src/compress/git-status.ts
+var GitStatusCompressor = class {
+  async compress(input) {
+    const { status } = input;
+    const statusLines = status.split("\n").filter(Boolean).length;
+    const tokens = Math.ceil(status.length / 4);
+    if (tokens < 10) {
+      return {
+        content: status,
+        original: status,
+        confidence: 1,
+        metadata: {
+          strategy: "passthrough",
+          totalFiles: statusLines,
+          savings: 0
+        }
+      };
+    }
+    const files = this.parseStatus(status);
+    const grouped = this.groupByStatus(files);
+    const lines = [];
+    for (const [statusType, statusFiles] of grouped) {
+      const label = this.statusLabel(statusType);
+      lines.push(`${label} (${statusFiles.length})`);
+      const compressed2 = this.compressPaths(statusFiles.map((f) => f.path));
+      lines.push(...compressed2);
+      lines.push("");
+    }
+    const compressed = lines.join("\n");
+    return {
+      content: compressed,
+      original: status,
+      confidence: calculateConfidence(status, compressed),
+      metadata: {
+        strategy: "grouped",
+        totalFiles: files.length,
+        savings: 1 - compressed.length / status.length
+      }
+    };
+  }
+  async decompress(compressed) {
+    return compressed.original;
+  }
+  parseStatus(status) {
+    return status.split("\n").filter(Boolean).map((line) => {
+      const match = line.match(/^(\?\?|[MADRC]+\s+)(.+)$/);
+      if (match) {
+        return { status: match[1].trim(), path: match[2] };
+      }
+      return { status: line[0], path: line.slice(3) };
+    });
+  }
+  groupByStatus(files) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const existing = grouped.get(file.status) || [];
+      existing.push(file);
+      grouped.set(file.status, existing);
+    }
+    return grouped;
+  }
+  statusLabel(status) {
+    const labels = {
+      "M": "Modified",
+      "A": "Added",
+      "D": "Deleted",
+      "??": "Untracked",
+      "R": "Renamed"
+    };
+    return labels[status] || `Status ${status}`;
+  }
+  compressPaths(paths) {
+    if (paths.length <= 3) return paths.map((p) => `  ${p}`);
+    const parts = paths.map((p) => p.split("/"));
+    const minLength = Math.min(...parts.map((p) => p.length));
+    let commonIndex = 0;
+    for (let i = 0; i < minLength; i++) {
+      if (parts.every((p) => p[i] === parts[0][i])) {
+        commonIndex = i;
+      } else {
+        break;
+      }
+    }
+    if (commonIndex > 0) {
+      const prefix = parts[0].slice(0, commonIndex).join("/");
+      const suffixes = paths.map((p) => p.slice(prefix.length + 1));
+      return [`  ${prefix}/`, ...suffixes.map((s) => `    ${s}`)];
+    }
+    return paths.map((p) => `  ${p}`);
+  }
+};
+
+// 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
+var PatternMiner = class {
+  operations = [];
+  patterns = /* @__PURE__ */ new Map();
+  record(operation) {
+    this.operations.push(operation);
+    if (operation.success) {
+      this.updatePatterns(operation);
+    }
+  }
+  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
+var FailureLearner = class {
+  failures = /* @__PURE__ */ new Map();
+  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
+      });
+    }
+  }
+  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
+var AutoCorrect = class {
+  rules = [];
+  corrections = [];
+  appliedCount = 0;
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+  getRules() {
+    return this.rules;
+  }
+  correct(input) {
+    let output = input;
+    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);
+        }
+      } else {
+        const matches = output.match(rule.pattern);
+        if (matches) {
+          output = output.replace(rule.pattern, rule.replacement);
+          this.recordCorrection(input, output, rule.name);
+        }
+      }
+    }
+    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/cache/l1-session.ts
+var SessionCache = class {
+  store = /* @__PURE__ */ new Map();
+  hits = 0;
+  misses = 0;
+  get(key) {
+    const entry = this.store.get(key);
+    if (entry) {
+      this.hits++;
+      return entry;
+    }
+    this.misses++;
+    return null;
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  clear() {
+    this.store.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  stats() {
+    const total = this.hits + this.misses;
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.store.size,
+      hitRate: total > 0 ? this.hits / total : 0
+    };
+  }
+};
+
+// src/web/backends/duckduckgo.ts
+var DuckDuckGoBackend = class {
+  name = "duckduckgo";
+  isAvailable() {
+    return true;
+  }
+  async search(query, options) {
+    const maxResults = options?.maxResults || 5;
+    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; make-laten/0.1.0)"
+      }
+    });
+    const html = await response.text();
+    return this.parseResults(html, maxResults);
+  }
+  parseResults(html, maxResults) {
+    const results = [];
+    const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+    const snippetRegex = /<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+    let match;
+    const urls = [];
+    const titles = [];
+    while ((match = resultRegex.exec(html)) !== null && urls.length < maxResults) {
+      const rawUrl = match[1];
+      const urlMatch = rawUrl.match(/uddg=([^&]+)/);
+      const url = urlMatch ? decodeURIComponent(urlMatch[1]) : rawUrl;
+      const title = this.stripTags(match[2]).trim();
+      if (url && title) {
+        urls.push(url);
+        titles.push(title);
+      }
+    }
+    const snippets = [];
+    while ((match = snippetRegex.exec(html)) !== null && snippets.length < maxResults) {
+      snippets.push(this.stripTags(match[1]).trim());
+    }
+    for (let i = 0; i < urls.length; i++) {
+      results.push({
+        title: titles[i],
+        url: urls[i],
+        snippet: snippets[i] || "",
+        score: 1 - i * 0.1
+      });
+    }
+    return results;
   }
-  condenseHunk(hunk) {
-    return hunk.lines.filter((l) => l.type === "addition" || l.type === "deletion").map((l) => `${l.type === "addition" ? "+" : "-"} ${l.content}`);
+  stripTags(html) {
+    return html.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&#x27;/g, "'").replace(/&quot;/g, '"');
   }
 };
 
+// src/web/backends/index.ts
+function selectBackend(preferred) {
+  const backends = [
+    new DuckDuckGoBackend()
+  ];
+  if (preferred) {
+    const found = backends.find((b) => b.name === preferred);
+    if (found) return found;
+  }
+  return backends.find((b) => b.isAvailable()) || backends[0];
+}
+
+// src/web/extractor.ts
+function stripTags(html) {
+  return html.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function extractTitle(html) {
+  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  if (titleMatch) return stripTags(titleMatch[1]).trim();
+  const h1Match = html.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+  if (h1Match) return stripTags(h1Match[1]).trim();
+  return "Untitled";
+}
+function extractSections(html) {
+  const sections = [];
+  const headingRegex = /<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi;
+  let match;
+  while ((match = headingRegex.exec(html)) !== null) {
+    const level = parseInt(match[1]);
+    const heading = stripTags(match[2]).trim();
+    const startPos = match.index + match[0].length;
+    const nextHeading = html.substring(startPos).match(/<h[1-6]/i);
+    const endPos = nextHeading ? startPos + nextHeading.index : html.length;
+    const content = stripTags(html.substring(startPos, endPos)).trim();
+    if (!content) continue;
+    const importance = level <= 2 ? "primary" : level <= 4 ? "secondary" : "tertiary";
+    sections.push({ heading, level, content, importance });
+  }
+  return sections;
+}
+function extractCodeExamples(html) {
+  const examples = [];
+  const codeRegex = /<(?:pre|code)[^>]*>[\s\S]*?<(?:code|\/pre)[^>]*>/gi;
+  const blockRegex = /<pre[^>]*><code[^>]*class="[^"]*language-(\w+)[^"]*"[^>]*>([\s\S]*?)<\/code><\/pre>/gi;
+  let match;
+  while ((match = blockRegex.exec(html)) !== null) {
+    const language = match[1];
+    const code = stripTags(match[2]).trim();
+    if (code.length > 10) {
+      examples.push({ language, code });
+    }
+  }
+  const inlineRegex = /<code[^>]*class="[^"]*language-(\w+)[^"]*"[^>]*>([\s\S]*?)<\/code>/gi;
+  while ((match = inlineRegex.exec(html)) !== null) {
+    const language = match[1];
+    const code = stripTags(match[2]).trim();
+    if (code.length > 20 && !examples.some((e) => e.code === code)) {
+      examples.push({ language, code });
+    }
+  }
+  return examples.slice(0, 10);
+}
+function extractKeyPoints(sections) {
+  const keyPoints = [];
+  for (const section of sections.filter((s) => s.importance === "primary")) {
+    const sentences = section.content.split(/[.!?\n]+/).filter((s) => s.trim().length > 10);
+    if (sentences.length > 0) {
+      keyPoints.push(sentences[0].trim());
+    }
+  }
+  return keyPoints.slice(0, 5);
+}
+function classifyPurpose(html, sections) {
+  const text = (html + " " + sections.map((s) => s.heading).join(" ")).toLowerCase();
+  if (text.includes("api reference") || text.includes("endpoint") || text.includes("parameters")) return "reference";
+  if (text.includes("tutorial") || text.includes("step by step") || text.includes("getting started")) return "tutorial";
+  if (text.includes("blog") || text.includes("published") || text.includes("author")) return "blog";
+  if (text.includes("install") || text.includes("quickstart") || text.includes("overview")) return "documentation";
+  return "documentation";
+}
+function extractSemantic(html, url) {
+  const title = extractTitle(html);
+  const sections = extractSections(html);
+  const codeExamples = extractCodeExamples(html);
+  const keyPoints = extractKeyPoints(sections);
+  const purpose = classifyPurpose(html, sections);
+  return {
+    type: "webpage",
+    url,
+    title,
+    purpose,
+    sections,
+    keyPoints,
+    codeExamples,
+    metadata: {
+      language: html.match(/lang="(\w+)"/)?.[1] || "en",
+      author: html.match(/<meta[^>]*name="author"[^>]*content="([^"]+)"/i)?.[1],
+      tags: html.match(/<meta[^>]*name="keywords"[^>]*content="([^"]+)"/i)?.[1]?.split(",").map((t) => t.trim())
+    }
+  };
+}
+
+// src/web/compressor.ts
+function compressWebContent(semantic, options = {}) {
+  const { maxTokens = 1e3, includeCode = true, includeSections = "all" } = options;
+  const lines = [];
+  lines.push(`# ${semantic.title}`);
+  lines.push(`URL: ${semantic.url}`);
+  lines.push(`Purpose: ${semantic.purpose}`);
+  lines.push("");
+  if (semantic.keyPoints.length > 0) {
+    lines.push("## Key Points");
+    for (const point of semantic.keyPoints) {
+      lines.push(`- ${point}`);
+    }
+    lines.push("");
+  }
+  const filteredSections = filterSections(semantic.sections, includeSections);
+  for (const section of filteredSections) {
+    const content = truncateContent(section.content, 500);
+    lines.push(`## ${section.heading}`);
+    lines.push(content);
+    lines.push("");
+  }
+  if (includeCode && semantic.codeExamples.length > 0) {
+    const topExamples = semantic.codeExamples.slice(0, 3);
+    lines.push("## Code Examples");
+    for (const example of topExamples) {
+      lines.push(`\`\`\`${example.language}`);
+      lines.push(truncateContent(example.code, 300));
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  let result = lines.join("\n");
+  const estimatedTokens = estimateTokens(result);
+  if (estimatedTokens > maxTokens) {
+    result = truncateByTokens(result, maxTokens);
+  }
+  return result;
+}
+function filterSections(sections, mode) {
+  if (mode === "none") return [];
+  if (mode === "primary") return sections.filter((s) => s.importance === "primary");
+  return sections;
+}
+function truncateContent(content, maxLength) {
+  if (content.length <= maxLength) return content;
+  return content.slice(0, maxLength) + "...";
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateByTokens(text, maxTokens) {
+  const maxChars = maxTokens * 4;
+  if (text.length <= maxChars) return text;
+  const truncated = text.slice(0, maxChars);
+  const lastNewline = truncated.lastIndexOf("\n");
+  return truncated.slice(0, lastNewline > 0 ? lastNewline : maxChars) + "\n\n... (truncated)";
+}
+
+// src/web/router.ts
+var WebRouter = class {
+  fetchCache = /* @__PURE__ */ new Map();
+  searchCache = /* @__PURE__ */ new Map();
+  cacheTtl;
+  constructor(options) {
+    this.cacheTtl = options?.cacheTtlMs || 60 * 60 * 1e3;
+  }
+  async search(query, options) {
+    const cacheKey = `search:${query}:${JSON.stringify(options || {})}`;
+    const cached = this.searchCache.get(cacheKey);
+    if (cached && this.isFresh(cacheKey)) {
+      return cached;
+    }
+    const backend = selectBackend(options?.backend);
+    const results = await backend.search(query, options);
+    this.searchCache.set(cacheKey, results);
+    this.storeFreshness(cacheKey);
+    return results;
+  }
+  async fetch(url, options) {
+    const cacheKey = `fetch:${url}:${options?.format || "text"}`;
+    if (options?.cache !== false) {
+      const cached = this.fetchCache.get(cacheKey);
+      if (cached && this.isFresh(cacheKey)) {
+        return cached;
+      }
+    }
+    const startTime = Date.now();
+    const response = await fetch(url);
+    const html = await response.text();
+    const originalSize = html.length;
+    let content;
+    let semantic = void 0;
+    if (options?.extract !== false) {
+      semantic = extractSemantic(html, url);
+      content = compressWebContent(semantic, {
+        includeCode: true,
+        includeSections: options?.format === "html" ? "all" : "primary"
+      });
+    } else {
+      content = html;
+    }
+    const compressedSize = content.length;
+    const result = {
+      url,
+      title: semantic?.title || extractSimpleTitle(html),
+      content,
+      semantic,
+      metadata: {
+        fetchTime: Date.now() - startTime,
+        originalSize,
+        compressedSize,
+        savings: 1 - compressedSize / originalSize
+      }
+    };
+    if (options?.cache !== false) {
+      this.fetchCache.set(cacheKey, result);
+      this.storeFreshness(cacheKey);
+    }
+    return result;
+  }
+  async extract(url) {
+    return this.fetch(url, { extract: true, compress: true });
+  }
+  async summarize(content, options) {
+    const lines = content.split("\n");
+    const summaryLines = [];
+    let tokenCount = 0;
+    const maxTokens = options?.maxTokens || 200;
+    for (const line of lines) {
+      const lineTokens = Math.ceil(line.length / 4);
+      if (tokenCount + lineTokens > maxTokens) break;
+      if (line.startsWith("#") || line.startsWith("-") || line.startsWith("*")) {
+        summaryLines.push(line);
+        tokenCount += lineTokens;
+      }
+    }
+    if (summaryLines.length === 0 && lines.length > 0) {
+      for (const line of lines.slice(0, 5)) {
+        const lineTokens = Math.ceil(line.length / 4);
+        if (tokenCount + lineTokens > maxTokens) break;
+        summaryLines.push(line);
+        tokenCount += lineTokens;
+      }
+    }
+    return summaryLines.join("\n");
+  }
+  clearCache() {
+    this.fetchCache.clear();
+    this.searchCache.clear();
+  }
+  getCacheStats() {
+    return {
+      fetchSize: this.fetchCache.size,
+      searchSize: this.searchCache.size
+    };
+  }
+  isFresh(key) {
+    const timestamp = this.freshness.get(key);
+    if (!timestamp) return false;
+    return Date.now() - timestamp < this.cacheTtl;
+  }
+  storeFreshness(key) {
+    this.freshness.set(key, Date.now());
+  }
+  freshness = /* @__PURE__ */ new Map();
+};
+function extractSimpleTitle(html) {
+  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return titleMatch ? titleMatch[1].replace(/<[^>]+>/g, "").trim() : "Untitled";
+}
+
 // src/mcp/server.ts
 import { exec } from "child_process";
 import { promisify } from "util";
 import fs from "fs/promises";
 var execAsync = promisify(exec);
+var sessionCache = new SessionCache();
+var toolRouter = new ToolRouter();
+var strategyRouter = new StrategyRouter();
+var patternMiner = new PatternMiner();
+var failureLearner = new FailureLearner();
+var autoCorrect = new AutoCorrect();
+var webRouter = new WebRouter();
 var TOOLS = [
+  // Compress Layer
   {
     name: "make-laten-read",
-    description: "Read and compress a file (60-90% token savings)",
+    description: "Read and compress a file (65-92% token savings)",
     inputSchema: {
       type: "object",
       properties: {
@@ -245,10 +1008,127 @@ var TOOLS = [
     description: "Compressed git status",
     inputSchema: { type: "object", properties: {} }
   },
+  // Route Layer
+  {
+    name: "make-laten-route",
+    description: "Route input to correct compressor",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: { type: "string", enum: ["file", "grep", "git-diff", "unknown"], description: "Input type" },
+        content: { type: "string", description: "Input content" }
+      },
+      required: ["type", "content"]
+    }
+  },
+  {
+    name: "make-laten-strategy",
+    description: "Select compression strategy based on context",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file_size: { type: "number", description: "File size in bytes" },
+        preference: { type: "string", enum: ["aggressive", "balanced", "conservative"], description: "Strategy preference" }
+      }
+    }
+  },
+  // Cache Layer
   {
     name: "make-laten-cache-stats",
     description: "Show cache performance stats",
     inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "make-laten-cache-get",
+    description: "Get value from session cache",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Cache key" }
+      },
+      required: ["key"]
+    }
+  },
+  {
+    name: "make-laten-cache-set",
+    description: "Set value in session cache",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Cache key" },
+        value: { type: "string", description: "Value to cache" }
+      },
+      required: ["key", "value"]
+    }
+  },
+  {
+    name: "make-laten-cache-clear",
+    description: "Clear session cache",
+    inputSchema: { type: "object", properties: {} }
+  },
+  // Learn Layer
+  {
+    name: "make-laten-patterns",
+    description: "Get learned patterns from usage",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "make-laten-failures",
+    description: "Get failure records and suggestions",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "make-laten-suggestions",
+    description: "Get suggestions based on learned patterns",
+    inputSchema: {
+      type: "object",
+      properties: {
+        context: { type: "string", description: "Context for suggestions" }
+      }
+    }
+  },
+  // Correct Layer
+  {
+    name: "make-laten-correct",
+    description: "Apply auto-corrections to text",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to correct" }
+      },
+      required: ["text"]
+    }
+  },
+  // Web Layer
+  {
+    name: "make-laten-search",
+    description: "Search the web with semantic understanding",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        backend: { type: "string", description: "Search backend (duckduckgo, exa, tavily)" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "make-laten-fetch",
+    description: "Fetch and compress web content",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to fetch" },
+        extract: { type: "boolean", description: "Extract semantic content", default: true }
+      },
+      required: ["url"]
+    }
+  },
+  // Tool Layer
+  {
+    name: "make-laten-tools",
+    description: "List available make-laten tools",
+    inputSchema: { type: "object", properties: {} }
   }
 ];
 function detectLanguage(filePath) {
@@ -278,9 +1158,9 @@ async function handleRead(params) {
     filePath: params.file_path,
     language: detectLanguage(params.file_path)
   });
-  return {
-    content: [{ type: "text", text: JSON.stringify({ compressed: result.content, savings: result.metadata.savings, confidence: result.confidence }) }]
-  };
+  patternMiner.record({ type: "file-read", input: { file: params.file_path }, success: true });
+  sessionCache.set(`file:${params.file_path}`, { content: result.content, metadata: result.metadata });
+  return { content: [{ type: "text", text: JSON.stringify({ compressed: result.content, savings: result.metadata.savings, confidence: result.confidence }) }] };
 }
 async function handleGrep(params) {
   const dir = params.path || ".";
@@ -294,6 +1174,7 @@ async function handleGrep(params) {
   });
   const compressor = new GrepCompressor();
   const result = await compressor.compress({ results: matches, pattern: params.pattern, directory: dir });
+  patternMiner.record({ type: "grep", input: { pattern: params.pattern, dir }, success: true });
   return { content: [{ type: "text", text: JSON.stringify({ compressed: result.content, total: matches.length, savings: result.metadata.savings }) }] };
 }
 async function handleGitDiff(params) {
@@ -304,23 +1185,98 @@ async function handleGitDiff(params) {
   }
   const compressor = new GitDiffCompressor();
   const result = await compressor.compress({ diff: stdout });
+  patternMiner.record({ type: "git-diff", input: { staged: params.staged }, success: true });
   return { content: [{ type: "text", text: JSON.stringify({ compressed: result.content, savings: result.metadata.savings }) }] };
 }
 async function handleGitStatus() {
   const { stdout } = await execAsync("git status --porcelain");
-  const lines = stdout.split("\n").filter(Boolean);
-  const files = lines.map((l) => ({ status: l[0], path: l.slice(3) }));
-  return { content: [{ type: "text", text: JSON.stringify({ total: files.length, files }) }] };
+  const compressor = new GitStatusCompressor();
+  const result = await compressor.compress({ status: stdout });
+  return { content: [{ type: "text", text: JSON.stringify({ compressed: result.content, savings: result.metadata.savings }) }] };
+}
+async function handleRoute(params) {
+  const route = toolRouter.route({ type: params.type, content: params.content });
+  return { content: [{ type: "text", text: JSON.stringify(route) }] };
+}
+async function handleStrategy(params) {
+  const strategy = strategyRouter.select({
+    fileSize: params.file_size,
+    userPreference: params.preference
+  });
+  return { content: [{ type: "text", text: JSON.stringify(strategy) }] };
 }
 async function handleCacheStats() {
-  return { content: [{ type: "text", text: JSON.stringify({ message: "Cache stats \u2014 use CLI: make-laten cache stats" }) }] };
+  const stats = sessionCache.stats();
+  return { content: [{ type: "text", text: JSON.stringify(stats) }] };
+}
+async function handleCacheGet(params) {
+  const entry = sessionCache.get(params.key);
+  return { content: [{ type: "text", text: JSON.stringify({ found: !!entry, entry }) }] };
+}
+async function handleCacheSet(params) {
+  sessionCache.set(params.key, { content: params.value, metadata: { setAt: Date.now() } });
+  return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+}
+async function handleCacheClear() {
+  sessionCache.clear();
+  return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+}
+async function handlePatterns() {
+  const patterns = patternMiner.getPatterns();
+  return { content: [{ type: "text", text: JSON.stringify({ patterns, total: patterns.length }) }] };
+}
+async function handleFailures() {
+  const failures = failureLearner.getFailures();
+  return { content: [{ type: "text", text: JSON.stringify({ failures, total: failures.length }) }] };
+}
+async function handleSuggestions(params) {
+  const patterns = patternMiner.getPatterns();
+  const failures = failureLearner.getFailures();
+  const suggestions = [];
+  for (const pattern of patterns.slice(0, 5)) {
+    suggestions.push(`Pattern: ${pattern.type} (confidence: ${pattern.confidence})`);
+  }
+  for (const failure of failures.slice(0, 5)) {
+    const failureSuggestions = failureLearner.getSuggestions(failure.type);
+    suggestions.push(...failureSuggestions);
+  }
+  return { content: [{ type: "text", text: JSON.stringify({ suggestions: [...new Set(suggestions)] }) }] };
+}
+async function handleCorrect(params) {
+  const corrected = autoCorrect.correct(params.text);
+  const stats = autoCorrect.getStats();
+  return { content: [{ type: "text", text: JSON.stringify({ original: params.text, corrected, corrections: stats.applied }) }] };
+}
+async function handleSearch(params) {
+  const results = await webRouter.search(params.query, { backend: params.backend });
+  return { content: [{ type: "text", text: JSON.stringify({ results, total: results.length }) }] };
+}
+async function handleFetch(params) {
+  const result = await webRouter.fetch(params.url, { extract: params.extract !== false });
+  return { content: [{ type: "text", text: JSON.stringify({ url: result.url, title: result.title, content: result.content, savings: result.metadata.savings }) }] };
+}
+async function handleTools() {
+  const tools = TOOLS.map((t) => ({ name: t.name, description: t.description }));
+  return { content: [{ type: "text", text: JSON.stringify({ tools, total: tools.length }) }] };
 }
 var handlers = {
   "make-laten-read": handleRead,
   "make-laten-grep": handleGrep,
   "make-laten-git-diff": handleGitDiff,
   "make-laten-git-status": handleGitStatus,
-  "make-laten-cache-stats": handleCacheStats
+  "make-laten-route": handleRoute,
+  "make-laten-strategy": handleStrategy,
+  "make-laten-cache-stats": handleCacheStats,
+  "make-laten-cache-get": handleCacheGet,
+  "make-laten-cache-set": handleCacheSet,
+  "make-laten-cache-clear": handleCacheClear,
+  "make-laten-patterns": handlePatterns,
+  "make-laten-failures": handleFailures,
+  "make-laten-suggestions": handleSuggestions,
+  "make-laten-correct": handleCorrect,
+  "make-laten-search": handleSearch,
+  "make-laten-fetch": handleFetch,
+  "make-laten-tools": handleTools
 };
 function sendResponse(id, result) {
   const response = { jsonrpc: "2.0", id, result };
@@ -337,7 +1293,7 @@ async function handleLine(line) {
       sendResponse(request.id, {
         protocolVersion: "2024-11-05",
         capabilities: { tools: {} },
-        serverInfo: { name: "make-laten", version: "1.0.0" }
+        serverInfo: { name: "make-laten", version: "1.2.0" }
       });
     } else if (request.method === "notifications/initialized") {
     } else if (request.method === "tools/list") {
@@ -353,6 +1309,7 @@ async function handleLine(line) {
         const result = await handler(params || {});
         sendResponse(request.id, result);
       } catch (error) {
+        failureLearner.record({ type: name, error: error.message, success: false });
         sendError(request.id, -32e3, error.message);
       }
     } else {
@@ -375,5 +1332,5 @@ process.stdin.on("data", async (chunk) => {
     }
   }
 });
-process.stderr.write("make-laten MCP server started\n");
+process.stderr.write("make-laten MCP server started (17 tools)\n");
 //# sourceMappingURL=server.mjs.map