make-laten 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1946 @@
+// src/graph/database.ts
+import Database from "better-sqlite3";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS nodes (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  content TEXT NOT NULL,
+  original TEXT,
+  embedding BLOB,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  accessed_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  access_count INTEGER DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source TEXT NOT NULL,
+  target TEXT NOT NULL,
+  type TEXT NOT NULL,
+  weight REAL DEFAULT 1.0,
+  metadata TEXT,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  FOREIGN KEY (source) REFERENCES nodes(id),
+  FOREIGN KEY (target) REFERENCES nodes(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
+CREATE INDEX IF NOT EXISTS idx_nodes_created ON nodes(created_at);
+CREATE INDEX IF NOT EXISTS idx_nodes_accessed ON nodes(accessed_at);
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target);
+CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
+`;
+async function createDatabase(dbPath) {
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(SCHEMA);
+  return db;
+}
+
+// src/graph/edges.ts
+var EdgeStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async add(edge) {
+    this.db.prepare(`
+      INSERT INTO edges (source, target, type, weight, metadata)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(
+      edge.source,
+      edge.target,
+      edge.type,
+      edge.weight,
+      edge.metadata ? JSON.stringify(edge.metadata) : null
+    );
+  }
+  async getFrom(source, type) {
+    let query = "SELECT * FROM edges WHERE source = ?";
+    const params = [source];
+    if (type) {
+      query += " AND type = ?";
+      params.push(type);
+    }
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => this.hydrate(row));
+  }
+  async getTo(target, type) {
+    let query = "SELECT * FROM edges WHERE target = ?";
+    const params = [target];
+    if (type) {
+      query += " AND type = ?";
+      params.push(type);
+    }
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => this.hydrate(row));
+  }
+  async delete(source, target) {
+    this.db.prepare("DELETE FROM edges WHERE source = ? AND target = ?").run(source, target);
+  }
+  hydrate(row) {
+    return {
+      id: row.id,
+      source: row.source,
+      target: row.target,
+      type: row.type,
+      weight: row.weight,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.created_at
+    };
+  }
+};
+
+// src/graph/nodes.ts
+var NodeStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async upsert(node) {
+    const stmt = this.db.prepare(`
+      INSERT INTO nodes (id, type, content, original, metadata, created_at, accessed_at, access_count)
+      VALUES (?, ?, ?, ?, ?, unixepoch(), unixepoch(), 1)
+      ON CONFLICT(id) DO UPDATE SET
+        content = excluded.content,
+        original = excluded.original,
+        metadata = excluded.metadata,
+        accessed_at = unixepoch(),
+        access_count = access_count + 1
+    `);
+    stmt.run(
+      node.id,
+      node.type,
+      node.content,
+      node.original || null,
+      JSON.stringify(node.metadata || {})
+    );
+  }
+  async get(id) {
+    this.db.prepare(`
+      UPDATE nodes SET accessed_at = unixepoch(), access_count = access_count + 1
+      WHERE id = ?
+    `).run(id);
+    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.hydrate(row);
+  }
+  async delete(id) {
+    this.db.prepare("DELETE FROM edges WHERE source = ? OR target = ?").run(id, id);
+    this.db.prepare("DELETE FROM nodes WHERE id = ?").run(id);
+  }
+  async listByType(type) {
+    const rows = this.db.prepare("SELECT * FROM nodes WHERE type = ?").all(type);
+    return rows.map((row) => this.hydrate(row));
+  }
+  hydrate(row) {
+    return {
+      id: row.id,
+      type: row.type,
+      content: row.content,
+      original: row.original || void 0,
+      embedding: row.embedding || void 0,
+      metadata: JSON.parse(row.metadata),
+      createdAt: row.created_at,
+      accessedAt: row.accessed_at,
+      accessCount: row.access_count
+    };
+  }
+};
+
+// src/compress/confidence.ts
+function calculateConfidence(original, compressed) {
+  if (!original.length) return 0;
+  let score = 1;
+  const ratio = compressed.length / original.length;
+  if (ratio < 0.01) score -= 0.5;
+  else if (ratio < 0.05) score -= 0.3;
+  if (codeBlocksModified(original, compressed)) score -= 0.4;
+  if (isKnownPattern(original)) score += 0.1;
+  return Math.max(0, Math.min(1, score));
+}
+function codeBlocksModified(original, compressed) {
+  const codeBlockRegex = /```[\s\S]*?```/g;
+  const originalBlocks = original.match(codeBlockRegex) || [];
+  const compressedBlocks = compressed.match(codeBlockRegex) || [];
+  if (originalBlocks.length !== compressedBlocks.length) return true;
+  for (let i = 0; i < originalBlocks.length; i++) {
+    if (originalBlocks[i] !== compressedBlocks[i]) return true;
+  }
+  return false;
+}
+function isKnownPattern(content) {
+  const patterns = [
+    /export\s+(default\s+)?(function|class|const|let|var)/,
+    /import\s+.*from\s+['"]/
+  ];
+  return patterns.some((p) => p.test(content));
+}
+
+// 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 = [
+      `// ${filePath} (${content.split("\n").length} lines)`,
+      "",
+      ...signatures,
+      "",
+      "// Exports:",
+      ...exports
+    ];
+    const compressed = lines.join("\n");
+    return {
+      content: compressed,
+      original: content,
+      confidence: calculateConfidence(content, compressed),
+      metadata: {
+        strategy: "signatures",
+        originalLines: content.split("\n").length,
+        compressedLines: lines.length,
+        savings: 1 - compressed.length / content.length
+      }
+    };
+  }
+  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/git-diff.ts
+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 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 compressed = lines.join("\n");
+    return {
+      content: compressed,
+      original: diff,
+      confidence: calculateConfidence(diff, compressed),
+      metadata: {
+        strategy: "condensed",
+        filesChanged: condensed.length,
+        savings: 1 - compressed.length / diff.length
+      }
+    };
+  }
+  async decompress(compressed) {
+    return compressed.original;
+  }
+  parseDiff(diff) {
+    const hunks = [];
+    const lines = diff.split("\n");
+    let currentHunk = 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: [],
+          additions: 0,
+          deletions: 0
+        };
+      } else if (currentHunk) {
+        if (line.startsWith("+")) {
+          currentHunk.additions++;
+          currentHunk.lines.push({ type: "addition", content: line.slice(1) });
+        } else if (line.startsWith("-")) {
+          currentHunk.deletions++;
+          currentHunk.lines.push({ type: "deletion", content: line.slice(1) });
+        }
+      }
+    }
+    if (currentHunk) hunks.push(currentHunk);
+    return hunks;
+  }
+  condenseHunk(hunk) {
+    return hunk.lines.filter((l) => l.type === "addition" || l.type === "deletion").map((l) => `${l.type === "addition" ? "+" : "-"} ${l.content}`);
+  }
+};
+
+// src/compress/grep.ts
+var GrepCompressor = class {
+  async compress(input) {
+    const { results } = input;
+    const grouped = this.groupByFile(results);
+    const lines = [];
+    for (const [file, matches] of grouped) {
+      lines.push(`${file} (${matches.length} matches)`);
+      const unique = this.deduplicate(matches);
+      for (const match of unique) {
+        lines.push(`  L${match.line}: ${match.content}`);
+      }
+    }
+    const compressed = lines.join("\n");
+    const original = results.map((r) => `${r.file}:${r.line}: ${r.content}`).join("\n");
+    return {
+      content: compressed,
+      original,
+      confidence: calculateConfidence(original, compressed),
+      metadata: {
+        strategy: "grouped",
+        totalMatches: results.length,
+        uniqueFiles: grouped.size,
+        savings: 1 - compressed.length / original.length
+      }
+    };
+  }
+  async decompress(compressed) {
+    return compressed.original;
+  }
+  groupByFile(results) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      const existing = grouped.get(result.file) || [];
+      existing.push(result);
+      grouped.set(result.file, existing);
+    }
+    return grouped;
+  }
+  deduplicate(matches) {
+    const seen = /* @__PURE__ */ new Set();
+    return matches.filter((match) => {
+      const key = match.content.trim();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+};
+
+// src/compress/output.ts
+var OutputCompressor = class {
+  static compress(input, options = {}) {
+    const { maxLength = 1e3, removeWhitespace = false, prettyPrint = false } = options;
+    let output = input;
+    if (removeWhitespace) {
+      output = output.replace(/\s+/g, " ").trim();
+    }
+    try {
+      const parsed = JSON.parse(output);
+      if (prettyPrint) {
+        output = JSON.stringify(parsed, null, 2);
+      } else {
+        output = JSON.stringify(parsed);
+      }
+    } catch {
+    }
+    if (output.length > maxLength) {
+      const suffix = "...[truncated]";
+      output = output.substring(0, maxLength - suffix.length) + suffix;
+    }
+    return output;
+  }
+};
+
+// 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/cache/l2-cross.ts
+var CrossSessionCache = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async get(key) {
+    const row = this.db.prepare(`
+      SELECT content, metadata, created_at 
+      FROM nodes 
+      WHERE id = ? AND type = 'cache'
+    `).get(key);
+    if (!row) return null;
+    const metadata = JSON.parse(row.metadata);
+    if (metadata.ttl) {
+      const age = Date.now() / 1e3 - row.created_at;
+      if (age > metadata.ttl) {
+        this.db.prepare("DELETE FROM nodes WHERE id = ?").run(key);
+        return null;
+      }
+    }
+    this.db.prepare(`
+      UPDATE nodes SET accessed_at = unixepoch(), access_count = access_count + 1
+      WHERE id = ?
+    `).run(key);
+    return {
+      content: row.content,
+      metadata: JSON.parse(row.metadata)
+    };
+  }
+  async set(key, value, options) {
+    this.db.prepare(`
+      INSERT INTO nodes (id, type, content, metadata, created_at, accessed_at, access_count)
+      VALUES (?, 'cache', ?, ?, unixepoch(), unixepoch(), 1)
+      ON CONFLICT(id) DO UPDATE SET
+        content = excluded.content,
+        metadata = excluded.metadata,
+        accessed_at = unixepoch(),
+        access_count = access_count + 1
+    `).run(key, value.content, JSON.stringify({ ...value.metadata, ttl: options?.ttl }));
+  }
+  async delete(key) {
+    this.db.prepare("DELETE FROM nodes WHERE id = ?").run(key);
+  }
+  async clear() {
+    this.db.prepare("DELETE FROM nodes WHERE type = 'cache'").run();
+  }
+};
+
+// src/cache/semantic.ts
+var SemanticCache = class {
+  entries = [];
+  store(content, embedding, metadata = {}) {
+    const entry = {
+      id: `sc${this.entries.length + 1}`,
+      content,
+      embedding,
+      metadata,
+      createdAt: Date.now()
+    };
+    this.entries.push(entry);
+    return entry;
+  }
+  search(query, minSimilarity = 0.8) {
+    const results = [];
+    for (const entry of this.entries) {
+      const similarity = this.cosineSimilarity(query, entry.embedding);
+      if (similarity >= minSimilarity) {
+        results.push({ entry, similarity });
+      }
+    }
+    return results.sort((a, b) => b.similarity - a.similarity);
+  }
+  getAll() {
+    return this.entries;
+  }
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+};
+
+// src/cache/index.ts
+function createCacheManager(db) {
+  const session = new SessionCache();
+  const crossSession = db ? new CrossSessionCache(db) : null;
+  const semantic = new SemanticCache();
+  return {
+    session,
+    crossSession,
+    semantic
+  };
+}
+function makeLatenCache(db) {
+  const l1 = new SessionCache();
+  const l2 = new CrossSessionCache(db);
+  return {
+    l1,
+    l2,
+    async get(key) {
+      const l1Result = l1.get(key);
+      if (l1Result) return l1Result;
+      const l2Result = await l2.get(key);
+      if (l2Result) {
+        l1.set(key, l2Result);
+        return l2Result;
+      }
+      return null;
+    },
+    async set(key, value, options) {
+      l1.set(key, value);
+      await l2.set(key, value, options);
+    },
+    async invalidate(pattern) {
+      l1.clear();
+      await l2.clear();
+    },
+    stats() {
+      return {
+        l1: l1.stats(),
+        l2: { size: 0 }
+      };
+    }
+  };
+}
+
+// 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/route/index.ts
+function createRouter() {
+  const tool = new ToolRouter();
+  const strategy = new StrategyRouter();
+  return {
+    tool,
+    strategy,
+    route: (input) => tool.route(input),
+    selectStrategy: (context) => strategy.select(context)
+  };
+}
+
+// src/tool/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(name, tool) {
+    this.tools.set(name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+};
+
+// src/tool/semantic-tool.ts
+var SemanticTool = class {
+  name;
+  intent;
+  inputTypes;
+  outputType;
+  constructor(name, config) {
+    this.name = name;
+    this.intent = config.intent;
+    this.inputTypes = new Set(config.inputTypes);
+    this.outputType = config.outputType;
+  }
+  supportsInput(inputType) {
+    return this.inputTypes.has(inputType);
+  }
+  describe() {
+    return `${this.name}: ${this.intent} (${Array.from(this.inputTypes).join(", ")} \u2192 ${this.outputType})`;
+  }
+};
+
+// src/tool/index.ts
+function createToolRegistry() {
+  const registry = new ToolRegistry();
+  registry.register("compress", {
+    name: "compress",
+    description: "Compress content to reduce tokens",
+    execute: async (input) => ({ content: "compressed", confidence: 0.9 })
+  });
+  registry.register("cache", {
+    name: "cache",
+    description: "Cache content for reuse",
+    execute: async (input) => ({ content: "cached", confidence: 1 })
+  });
+  registry.register("graph", {
+    name: "graph",
+    description: "Store in knowledge graph",
+    execute: async (input) => ({ stored: true })
+  });
+  return registry;
+}
+function getSemanticTools() {
+  return [
+    new SemanticTool("compress", {
+      intent: "Reduce token usage",
+      inputTypes: ["file", "grep", "git-diff"],
+      outputType: "compressed"
+    }),
+    new SemanticTool("cache", {
+      intent: "Store for reuse",
+      inputTypes: ["compressed", "original"],
+      outputType: "cached"
+    }),
+    new SemanticTool("graph", {
+      intent: "Build knowledge base",
+      inputTypes: ["any"],
+      outputType: "stored"
+    })
+  ];
+}
+
+// src/adapter/claude-code.ts
+var ClaudeCodeAdapter = class {
+  name = "claude-code";
+  version = "1.0.0";
+  type = "hook";
+  format(input) {
+    const { content, context } = input;
+    const formatted = this.formatForClaude(content, context);
+    return {
+      output: formatted,
+      format: "claude",
+      metadata: {
+        filePath: context?.filePath,
+        timestamp: Date.now()
+      }
+    };
+  }
+  parse(output) {
+    return { content: output, parsed: true };
+  }
+  formatForClaude(content, context) {
+    const parts = [];
+    if (context?.filePath) {
+      parts.push(`**File:** \`${context.filePath}\``);
+    }
+    parts.push(content);
+    return parts.join("\n\n");
+  }
+};
+
+// src/adapter/codex.ts
+var CodexAdapter = class {
+  name = "codex";
+  version = "1.0.0";
+  type = "hook";
+  format(input) {
+    const { content, context } = input;
+    const formatted = this.formatForCodex(content, context);
+    return {
+      output: formatted,
+      format: "codex",
+      metadata: {
+        timestamp: Date.now()
+      }
+    };
+  }
+  parse(output) {
+    try {
+      return JSON.parse(output);
+    } catch {
+      return { content: output };
+    }
+  }
+  formatForCodex(content, context) {
+    if (context?.expectJson) {
+      return JSON.stringify({ content, timestamp: Date.now() });
+    }
+    return content;
+  }
+};
+
+// src/adapter/gemini-cli.ts
+var GeminiCliAdapter = class {
+  name = "gemini-cli";
+  version = "1.0.0";
+  type = "hook";
+  format(input) {
+    const { content, context } = input;
+    const formatted = this.formatForGemini(content, context);
+    const multimodal = context?.includeImage || false;
+    return {
+      output: formatted,
+      format: "gemini",
+      metadata: {
+        multimodal,
+        imagePath: context?.imagePath,
+        timestamp: Date.now()
+      }
+    };
+  }
+  parse(output) {
+    return { content: output, parsed: true };
+  }
+  formatForGemini(content, context) {
+    const parts = [content];
+    if (context?.includeImage && context?.imagePath) {
+      parts.push(`[Image: ${context.imagePath}]`);
+    }
+    return parts.join("\n");
+  }
+};
+
+// src/adapter/hook.ts
+import fs from "fs/promises";
+import path from "path";
+var HookAdapter = class {
+  name;
+  version = "1.0.0";
+  type = "hook";
+  hooks = {};
+  constructor(name) {
+    this.name = name;
+  }
+  format(input) {
+    const { content, context } = input;
+    const parts = [];
+    if (context?.filePath) {
+      parts.push(`**File:** \`${context.filePath}\``);
+    }
+    parts.push(content);
+    return {
+      output: parts.join("\n\n"),
+      format: this.name,
+      metadata: { filePath: context?.filePath, timestamp: Date.now() }
+    };
+  }
+  parse(output) {
+    return { content: output, parsed: true };
+  }
+  setHooks(hooks) {
+    this.hooks = hooks;
+  }
+  async intercept(toolCall) {
+    if (this.hooks.preToolUse) {
+      return this.hooks.preToolUse(toolCall);
+    }
+    return toolCall;
+  }
+  async postProcess(result) {
+    if (this.hooks.postToolUse) {
+      return this.hooks.postToolUse(result);
+    }
+    return result;
+  }
+  async install(agentPath) {
+    const hooksDir = path.join(agentPath, "hooks");
+    await fs.mkdir(hooksDir, { recursive: true });
+    const preToolHook = `#!/usr/bin/env node
+const { readFileSync } = require('fs');
+const input = JSON.parse(readFileSync('/dev/stdin', 'utf-8'));
+
+if (input.tool === 'Read' || input.tool === 'Bash') {
+  process.env.MAKE_LATEN_INTERCEPT = '1';
+}
+
+process.stdout.write(JSON.stringify(input));
+`;
+    const postToolHook = `#!/usr/bin/env node
+const { readFileSync } = require('fs');
+const input = JSON.parse(readFileSync('/dev/stdin', 'utf-8'));
+
+if (input.output && input.output.length > 10000) {
+  input.output = input.output.slice(0, 10000) + '\\n... (truncated by make-laten)';
+}
+
+process.stdout.write(JSON.stringify(input));
+`;
+    await fs.writeFile(path.join(hooksDir, "pre-tool-use.js"), preToolHook);
+    await fs.writeFile(path.join(hooksDir, "post-tool-use.js"), postToolHook);
+  }
+  async uninstall(agentPath) {
+    const hooksDir = path.join(agentPath, "hooks");
+    try {
+      await fs.rm(path.join(hooksDir, "pre-tool-use.js"), { force: true });
+      await fs.rm(path.join(hooksDir, "post-tool-use.js"), { force: true });
+    } catch {
+    }
+  }
+  async isInstalled(agentPath) {
+    try {
+      await fs.access(path.join(agentPath, "hooks", "pre-tool-use.js"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapter/rules.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/adapter/types.ts
+var AGENT_CONFIGS = {
+  "claude-code": { type: "hook" },
+  "codex": { type: "hook" },
+  "gemini-cli": { type: "hook" },
+  "cursor": { type: "rules", rulesFile: ".cursorrules" },
+  "windsurf": { type: "rules", rulesFile: ".windsurfrules" },
+  "cline": { type: "rules", rulesFile: ".clinerules" },
+  "copilot": { type: "rules", rulesFile: ".github/copilot-instructions.md" }
+};
+
+// src/adapter/rules.ts
+var RULES_TEMPLATE = `
+# make-laten efficiency rules
+
+## Token Optimization
+- When reading files, prefer using \`make-laten read <file>\` for compressed output
+- When searching code, prefer using \`make-laten grep <pattern>\` for grouped results
+- When checking git status, prefer using \`make-laten git diff\` for condensed output
+
+## Caching
+- make-laten automatically caches frequently accessed files
+- Use \`make-laten cache stats\` to see cache performance
+- Use \`make-laten cache clear\` to reset cache if needed
+
+## Web Search
+- Use \`make-laten search <query>\` for optimized web search
+- Use \`make-laten fetch <url>\` for compressed web fetch
+`;
+var RulesAdapter = class {
+  name;
+  version = "1.0.0";
+  type = "rules";
+  constructor(agentName) {
+    this.name = agentName;
+  }
+  format(input) {
+    return {
+      output: input.content,
+      format: "markdown",
+      metadata: { agent: this.name, timestamp: Date.now() }
+    };
+  }
+  parse(output) {
+    return { content: output };
+  }
+  async install(agentPath) {
+    const config = AGENT_CONFIGS[this.name];
+    if (!config?.rulesFile) {
+      throw new Error(`No rules file configured for ${this.name}`);
+    }
+    const rulesPath = path2.join(agentPath, config.rulesFile);
+    const existing = await fs2.readFile(rulesPath, "utf-8").catch(() => "");
+    if (existing.includes("make-laten")) {
+      return;
+    }
+    await fs2.mkdir(path2.dirname(rulesPath), { recursive: true });
+    await fs2.writeFile(rulesPath, existing + "\n\n" + RULES_TEMPLATE);
+  }
+  async uninstall(agentPath) {
+    const config = AGENT_CONFIGS[this.name];
+    if (!config?.rulesFile) return;
+    const rulesPath = path2.join(agentPath, config.rulesFile);
+    try {
+      let content = await fs2.readFile(rulesPath, "utf-8");
+      const marker = "# make-laten efficiency rules";
+      const idx = content.indexOf(marker);
+      if (idx !== -1) {
+        const endIdx = content.indexOf("\n#", idx + marker.length);
+        content = content.slice(0, idx).trim() + "\n" + (endIdx !== -1 ? content.slice(endIdx) : "");
+        await fs2.writeFile(rulesPath, content.trim() + "\n");
+      }
+    } catch {
+    }
+  }
+  async isInstalled(agentPath) {
+    const config = AGENT_CONFIGS[this.name];
+    if (!config?.rulesFile) return false;
+    try {
+      const content = await fs2.readFile(path2.join(agentPath, config.rulesFile), "utf-8");
+      return content.includes("make-laten");
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapter/detector.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs3 from "fs/promises";
+import path3 from "path";
+var execAsync = promisify(exec);
+var AgentDetector = class {
+  async detectAgents() {
+    const agents = [];
+    for (const [name, config] of Object.entries(AGENT_CONFIGS)) {
+      const detected = await this.detectAgent(name, config.type);
+      if (detected) {
+        agents.push(detected);
+      }
+    }
+    return agents;
+  }
+  async detectAgent(name, type) {
+    const commands = {
+      "claude-code": "claude --version",
+      "codex": "codex --version",
+      "gemini-cli": "gemini --version"
+    };
+    if (commands[name]) {
+      try {
+        const { stdout } = await execAsync(commands[name], { timeout: 5e3 });
+        const version = stdout.trim().split("\n")[0];
+        const agentPath = await this.getAgentPath(name);
+        return { name, type, path: agentPath, version, detected: true };
+      } catch {
+        return null;
+      }
+    }
+    if (type === "rules") {
+      const rulesPath = AGENT_CONFIGS[name]?.rulesFile;
+      if (rulesPath) {
+        try {
+          await fs3.access(path3.join(process.cwd(), rulesPath));
+          return { name, type, path: process.cwd(), version: null, detected: true };
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  async getAgentPath(name) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const paths = {
+      "claude-code": path3.join(home, ".claude"),
+      "codex": path3.join(home, ".codex"),
+      "gemini-cli": path3.join(home, ".gemini")
+    };
+    return paths[name] || path3.join(home, `.${name}`);
+  }
+  async hasCommand(cmd) {
+    try {
+      await execAsync(`which ${cmd}`, { timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapter/installer.ts
+var Installer = class {
+  detector = new AgentDetector();
+  async install() {
+    const agents = await this.detector.detectAgents();
+    const installed = [];
+    const skipped = [];
+    for (const agent of agents) {
+      try {
+        const adapter = this.createAdapter(agent);
+        if (adapter.install) {
+          await adapter.install(agent.path);
+          installed.push(agent.name);
+        } else {
+          skipped.push(agent.name);
+        }
+      } catch {
+        skipped.push(agent.name);
+      }
+    }
+    return { installed, skipped };
+  }
+  async uninstall() {
+    const agents = await this.detector.detectAgents();
+    const removed = [];
+    for (const agent of agents) {
+      try {
+        const adapter = this.createAdapter(agent);
+        if (adapter.uninstall) {
+          await adapter.uninstall(agent.path);
+          removed.push(agent.name);
+        }
+      } catch {
+      }
+    }
+    return { removed };
+  }
+  async status() {
+    const agents = await this.detector.detectAgents();
+    for (const agent of agents) {
+      const adapter = this.createAdapter(agent);
+      if (adapter.isInstalled) {
+        agent.detected = await adapter.isInstalled(agent.path);
+      }
+    }
+    return agents;
+  }
+  createAdapter(agent) {
+    const config = AGENT_CONFIGS[agent.name];
+    if (config?.type === "rules") {
+      return new RulesAdapter(agent.name);
+    }
+    return new HookAdapter(agent.name);
+  }
+};
+
+// src/adapter/index.ts
+var adapters = /* @__PURE__ */ new Map();
+adapters.set("claude-code", new ClaudeCodeAdapter());
+adapters.set("codex", new CodexAdapter());
+adapters.set("gemini-cli", new GeminiCliAdapter());
+function getAdapter(name) {
+  return adapters.get(name);
+}
+function getAdapters() {
+  return Array.from(adapters.values());
+}
+function createAdapter(config) {
+  return config;
+}
+function registerAdapter(name, adapter) {
+  adapters.set(name, adapter);
+}
+function createHookAdapter(name) {
+  return new HookAdapter(name);
+}
+function createRulesAdapter(name) {
+  return new RulesAdapter(name);
+}
+function createInstaller() {
+  return new Installer();
+}
+function createDetector() {
+  return new AgentDetector();
+}
+
+// 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/learn/index.ts
+function createLearner() {
+  const patterns = new PatternMiner();
+  const failures = new FailureLearner();
+  return {
+    patterns,
+    failures,
+    record: (op) => {
+      patterns.record(op);
+      if (!op.success) {
+        failures.record({
+          type: op.type,
+          error: op.error || "Unknown error",
+          context: op.input
+        });
+      }
+    }
+  };
+}
+
+// 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/correct/index.ts
+var defaultRules = [
+  {
+    name: "fix-typo-teh",
+    description: 'Fix "teh" typo',
+    pattern: "teh",
+    replacement: "the"
+  },
+  {
+    name: "fix-typo-recieve",
+    description: 'Fix "recieve" typo',
+    pattern: "recieve",
+    replacement: "receive"
+  }
+];
+function createCorrector(rules = defaultRules) {
+  const engine = new AutoCorrect();
+  for (const rule of rules) {
+    engine.addRule(rule);
+  }
+  return {
+    engine,
+    rules: engine.getRules(),
+    correct: (input) => engine.correct(input)
+  };
+}
+
+// src/middleware/pipeline.ts
+var Pipeline = class {
+  middlewares = [];
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return this;
+  }
+  size() {
+    return this.middlewares.length;
+  }
+  async execute(ctx) {
+    let index = 0;
+    const next = async (ctx2) => {
+      if (index >= this.middlewares.length) {
+        return { output: ctx2.input, metadata: ctx2.metadata };
+      }
+      const middleware = this.middlewares[index++];
+      return middleware(ctx2, next);
+    };
+    return next(ctx);
+  }
+};
+
+// src/plugin/loader.ts
+var PluginLoader = class {
+  plugins = /* @__PURE__ */ new Map();
+  register(plugin) {
+    this.plugins.set(plugin.name, plugin);
+  }
+  get(name) {
+    return this.plugins.get(name);
+  }
+  has(name) {
+    return this.plugins.has(name);
+  }
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  async initializeAll(ctx) {
+    for (const plugin of this.plugins.values()) {
+      await plugin.initialize(ctx);
+    }
+  }
+  async destroyAll() {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.destroy) {
+        await plugin.destroy();
+      }
+    }
+  }
+};
+
+// src/security/rate-limiter.ts
+var RateLimiter = class {
+  config;
+  records = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  allow(key) {
+    const now = Date.now();
+    const record = this.records.get(key);
+    if (!record || now > record.resetAt) {
+      this.records.set(key, { count: 1, resetAt: now + this.config.windowMs });
+      return true;
+    }
+    if (record.count >= this.config.maxRequests) {
+      return false;
+    }
+    record.count++;
+    return true;
+  }
+  getUsage(key) {
+    const record = this.records.get(key);
+    if (!record || Date.now() > record.resetAt) {
+      return 0;
+    }
+    return record.count;
+  }
+  reset(key) {
+    this.records.delete(key);
+  }
+};
+
+// src/logging/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  debug(message, metadata) {
+    this.log("debug", message, metadata);
+  }
+  info(message, metadata) {
+    this.log("info", message, metadata);
+  }
+  warn(message, metadata) {
+    this.log("warn", message, metadata);
+  }
+  error(message, metadata) {
+    this.log("error", message, metadata);
+  }
+  log(level, message, metadata) {
+    if (LOG_LEVELS[level] >= LOG_LEVELS[this.config.level]) {
+      this.config.handler({
+        level,
+        message,
+        metadata,
+        timestamp: Date.now()
+      });
+    }
+  }
+};
+
+// src/error/handler.ts
+var ErrorHandler = class {
+  errors = [];
+  handle(error) {
+    this.errors.push(error);
+    const category = this.categorize(error);
+    const suggestions = this.getSuggestions(error);
+    return {
+      handled: true,
+      category,
+      suggestions
+    };
+  }
+  getStats() {
+    const byCategory = {};
+    for (const error of this.errors) {
+      const cat = this.categorize(error);
+      byCategory[cat] = (byCategory[cat] || 0) + 1;
+    }
+    return { total: this.errors.length, byCategory };
+  }
+  categorize(error) {
+    if (error.message.includes("not found")) return "not-found";
+    if (error.message.includes("permission")) return "permission";
+    if (error.message.includes("timeout")) return "timeout";
+    return "unknown";
+  }
+  getSuggestions(error) {
+    const suggestions = [];
+    if (error.message.includes("not found")) {
+      suggestions.push("check if file or resource exists");
+    }
+    if (error.message.includes("permission")) {
+      suggestions.push("verify access permissions");
+    }
+    if (error.message.includes("timeout")) {
+      suggestions.push("increase timeout or retry");
+    }
+    return suggestions;
+  }
+};
+
+// src/metrics/collector.ts
+var MetricsCollector = class {
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  increment(name, value = 1) {
+    this.counters.set(name, (this.counters.get(name) || 0) + value);
+  }
+  getCounter(name) {
+    return this.counters.get(name) || 0;
+  }
+  setGauge(name, value) {
+    this.gauges.set(name, value);
+  }
+  getGauge(name) {
+    return this.gauges.get(name) || 0;
+  }
+  record(name, value) {
+    const values = this.histograms.get(name) || [];
+    values.push(value);
+    this.histograms.set(name, values);
+  }
+  getHistogram(name) {
+    const values = this.histograms.get(name) || [];
+    if (values.length === 0) {
+      return { avg: 0, min: 0, max: 0, count: 0 };
+    }
+    return {
+      avg: values.reduce((a, b) => a + b, 0) / values.length,
+      min: Math.min(...values),
+      max: Math.max(...values),
+      count: values.length
+    };
+  }
+  reset() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+  }
+};
+
+// src/session/manager.ts
+var SessionManager = class {
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  create(userId) {
+    const session = {
+      id: `s${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      userId,
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now()
+    };
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  get(id) {
+    const session = this.sessions.get(id);
+    if (session && Date.now() - session.lastAccessedAt > this.config.timeoutMs) {
+      this.sessions.delete(id);
+      return void 0;
+    }
+    if (session) {
+      session.lastAccessedAt = Date.now();
+    }
+    return session;
+  }
+  destroy(id) {
+    this.sessions.delete(id);
+  }
+  getActive() {
+    const now = Date.now();
+    return Array.from(this.sessions.values()).filter(
+      (s) => now - s.lastAccessedAt <= this.config.timeoutMs
+    );
+  }
+};
+
+// 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;
+  }
+  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/index.ts
+var VERSION = "0.1.0";
+export {
+  AGENT_CONFIGS,
+  AgentDetector,
+  AutoCorrect,
+  ClaudeCodeAdapter,
+  CodexAdapter,
+  CrossSessionCache,
+  DuckDuckGoBackend,
+  EdgeStore,
+  ErrorHandler,
+  FailureLearner,
+  FileReadCompressor,
+  GeminiCliAdapter,
+  GitDiffCompressor,
+  GrepCompressor,
+  HookAdapter,
+  Installer,
+  Logger,
+  MetricsCollector,
+  NodeStore,
+  OutputCompressor,
+  PatternMiner,
+  Pipeline,
+  PluginLoader,
+  RateLimiter,
+  RulesAdapter,
+  SemanticCache,
+  SemanticTool,
+  SessionCache,
+  SessionManager,
+  StrategyRouter,
+  ToolRegistry,
+  ToolRouter,
+  VERSION,
+  WebRouter,
+  calculateConfidence,
+  compressWebContent,
+  createAdapter,
+  createCacheManager,
+  createCorrector,
+  createDatabase,
+  createDetector,
+  createHookAdapter,
+  createInstaller,
+  createLearner,
+  createRouter,
+  createRulesAdapter,
+  createToolRegistry,
+  extractSemantic,
+  getAdapter,
+  getAdapters,
+  getSemanticTools,
+  makeLatenCache,
+  registerAdapter,
+  selectBackend
+};
+//# sourceMappingURL=index.mjs.map