make-laten 1.0.0

package/dist/cli/index.mjs

@@ -0,0 +1,1279 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/read.ts
+import fs from "fs/promises";
+
+// 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/cli/commands/read.ts
+function detectLanguage(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() || "";
+  const langMap = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    py: "python",
+    rs: "rust",
+    go: "go",
+    java: "java",
+    rb: "ruby",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml",
+    md: "markdown"
+  };
+  return langMap[ext] || "text";
+}
+async function readCommand(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const compressor = new FileReadCompressor();
+    const result = await compressor.compress({
+      content,
+      filePath,
+      language: detectLanguage(filePath)
+    });
+    console.log(JSON.stringify({
+      file: filePath,
+      compressed: result.content,
+      confidence: result.confidence,
+      metadata: result.metadata
+    }, null, 2));
+  } catch (error) {
+    console.error(`Error reading ${filePath}:`, error);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/grep.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// 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/cli/commands/grep.ts
+var execAsync = promisify(exec);
+function parseGrepOutput(output) {
+  const matches = [];
+  const lines = output.split("\n").filter(Boolean);
+  for (const line of lines) {
+    const parts = line.split(":");
+    if (parts.length >= 3) {
+      matches.push({
+        file: parts[0],
+        line: parseInt(parts[1], 10) || 0,
+        content: parts.slice(2).join(":").trim()
+      });
+    }
+  }
+  return matches;
+}
+async function grepCommand(pattern, directory, options) {
+  try {
+    let cmd = `grep -rn "${pattern}" ${directory}`;
+    if (options.ignore) {
+      cmd += ` --include="*.${options.ignore}"`;
+    }
+    const { stdout } = await execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 });
+    const matches = parseGrepOutput(stdout);
+    if (matches.length === 0) {
+      console.log(JSON.stringify({ pattern, directory, matches: [], total: 0 }));
+      return;
+    }
+    const compressor = new GrepCompressor();
+    const result = await compressor.compress({
+      results: matches,
+      pattern,
+      directory
+    });
+    console.log(JSON.stringify({
+      pattern,
+      directory,
+      compressed: result.content,
+      confidence: result.confidence,
+      total: matches.length,
+      metadata: result.metadata
+    }, null, 2));
+  } catch (error) {
+    if (error.code === 1) {
+      console.log(JSON.stringify({ pattern, directory, matches: [], total: 0 }));
+    } else {
+      console.error(`Error grep:`, error.message);
+      process.exit(1);
+    }
+  }
+}
+
+// src/cli/commands/git.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// 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/cli/commands/git.ts
+var execAsync2 = promisify2(exec2);
+async function gitDiffCommand(options) {
+  try {
+    const flag = options.staged ? "--staged" : "";
+    const { stdout } = await execAsync2(`git diff ${flag}`, { maxBuffer: 10 * 1024 * 1024 });
+    if (!stdout.trim()) {
+      console.log(JSON.stringify({ diff: "", changes: 0 }));
+      return;
+    }
+    const compressor = new GitDiffCompressor();
+    const result = await compressor.compress({ diff: stdout });
+    console.log(JSON.stringify({
+      compressed: result.content,
+      confidence: result.confidence,
+      metadata: result.metadata
+    }, null, 2));
+  } catch (error) {
+    console.error(`Error git diff:`, error.message);
+    process.exit(1);
+  }
+}
+async function gitStatusCommand() {
+  try {
+    const { stdout } = await execAsync2("git status --porcelain");
+    const lines = stdout.split("\n").filter(Boolean);
+    const files = lines.map((line) => ({
+      status: line[0],
+      path: line.slice(3)
+    }));
+    console.log(JSON.stringify({
+      total: files.length,
+      files
+    }, null, 2));
+  } catch (error) {
+    console.error(`Error git status:`, error.message);
+    process.exit(1);
+  }
+}
+
+// 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/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/index.ts
+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/cli/commands/cache.ts
+async function cacheStatsCommand() {
+  try {
+    const dbPath = process.env.MAKE_LATEN_DB || ".make-laten.db";
+    const db = await createDatabase(dbPath);
+    const cache = makeLatenCache(db);
+    const stats = cache.stats();
+    console.log(JSON.stringify({
+      l1: {
+        hits: stats.l1.hits,
+        misses: stats.l1.misses,
+        size: stats.l1.size,
+        hitRate: `${(stats.l1.hitRate * 100).toFixed(1)}%`
+      },
+      l2: {
+        size: stats.l2.size
+      }
+    }, null, 2));
+    db.close();
+  } catch (error) {
+    console.error(`Error cache stats:`, error.message);
+    process.exit(1);
+  }
+}
+async function cacheClearCommand() {
+  try {
+    const dbPath = process.env.MAKE_LATEN_DB || ".make-laten.db";
+    const db = await createDatabase(dbPath);
+    const cache = makeLatenCache(db);
+    await cache.invalidate("*");
+    console.log(JSON.stringify({ cleared: true }));
+    db.close();
+  } catch (error) {
+    console.error(`Error cache clear:`, error.message);
+    process.exit(1);
+  }
+}
+
+// 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/cli/commands/web.ts
+async function searchCommand(query, options) {
+  try {
+    const router = new WebRouter();
+    const results = await router.search(query, {
+      maxResults: options.max || 5,
+      backend: options.backend
+    });
+    console.log(JSON.stringify({
+      query,
+      total: results.length,
+      results: results.map((r) => ({
+        title: r.title,
+        url: r.url,
+        snippet: r.snippet,
+        score: r.score
+      }))
+    }, null, 2));
+  } catch (error) {
+    console.error(`Error search:`, error.message);
+    process.exit(1);
+  }
+}
+async function fetchCommand(url, options) {
+  try {
+    const router = new WebRouter();
+    const result = await router.fetch(url, {
+      compress: options.compress !== false,
+      extract: options.extract !== false,
+      cache: true
+    });
+    console.log(JSON.stringify({
+      url: result.url,
+      title: result.title,
+      content: result.content,
+      metadata: result.metadata
+    }, null, 2));
+  } catch (error) {
+    console.error(`Error fetch:`, error.message);
+    process.exit(1);
+  }
+}
+
+// src/adapter/detector.ts
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import fs2 from "fs/promises";
+import path 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/detector.ts
+var execAsync3 = promisify3(exec3);
+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 execAsync3(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 fs2.access(path.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": path.join(home, ".claude"),
+      "codex": path.join(home, ".codex"),
+      "gemini-cli": path.join(home, ".gemini")
+    };
+    return paths[name] || path.join(home, `.${name}`);
+  }
+  async hasCommand(cmd) {
+    try {
+      await execAsync3(`which ${cmd}`, { timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapter/hook.ts
+import fs3 from "fs/promises";
+import path2 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 = path2.join(agentPath, "hooks");
+    await fs3.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 fs3.writeFile(path2.join(hooksDir, "pre-tool-use.js"), preToolHook);
+    await fs3.writeFile(path2.join(hooksDir, "post-tool-use.js"), postToolHook);
+  }
+  async uninstall(agentPath) {
+    const hooksDir = path2.join(agentPath, "hooks");
+    try {
+      await fs3.rm(path2.join(hooksDir, "pre-tool-use.js"), { force: true });
+      await fs3.rm(path2.join(hooksDir, "post-tool-use.js"), { force: true });
+    } catch {
+    }
+  }
+  async isInstalled(agentPath) {
+    try {
+      await fs3.access(path2.join(agentPath, "hooks", "pre-tool-use.js"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapter/rules.ts
+import fs4 from "fs/promises";
+import path3 from "path";
+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 = path3.join(agentPath, config.rulesFile);
+    const existing = await fs4.readFile(rulesPath, "utf-8").catch(() => "");
+    if (existing.includes("make-laten")) {
+      return;
+    }
+    await fs4.mkdir(path3.dirname(rulesPath), { recursive: true });
+    await fs4.writeFile(rulesPath, existing + "\n\n" + RULES_TEMPLATE);
+  }
+  async uninstall(agentPath) {
+    const config = AGENT_CONFIGS[this.name];
+    if (!config?.rulesFile) return;
+    const rulesPath = path3.join(agentPath, config.rulesFile);
+    try {
+      let content = await fs4.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 fs4.writeFile(rulesPath, content.trim() + "\n");
+      }
+    } catch {
+    }
+  }
+  async isInstalled(agentPath) {
+    const config = AGENT_CONFIGS[this.name];
+    if (!config?.rulesFile) return false;
+    try {
+      const content = await fs4.readFile(path3.join(agentPath, config.rulesFile), "utf-8");
+      return content.includes("make-laten");
+    } 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/cli/commands/install.ts
+async function installCommand(options) {
+  const installer = new Installer();
+  if (options.status) {
+    console.log("Detecting installed agents...\n");
+    const agents = await installer.status();
+    if (agents.length === 0) {
+      console.log("No supported agents detected.");
+      return;
+    }
+    for (const agent of agents) {
+      const status = agent.detected ? "\u2713 installed" : "\u25CB detected";
+      console.log(`  ${status}  ${agent.name} (${agent.type})${agent.version ? ` v${agent.version}` : ""}`);
+    }
+    return;
+  }
+  if (options.uninstall) {
+    console.log("Uninstalling make-laten adapters...\n");
+    const { removed } = await installer.uninstall();
+    if (removed.length === 0) {
+      console.log("Nothing to uninstall.");
+      return;
+    }
+    for (const name of removed) {
+      console.log(`  \u2713 removed from ${name}`);
+    }
+    return;
+  }
+  console.log("Installing make-laten adapters...\n");
+  const { installed, skipped } = await installer.install();
+  if (installed.length === 0 && skipped.length === 0) {
+    console.log("No supported agents detected.");
+    console.log("make-laten CLI works standalone \u2014 use commands directly:");
+    console.log("  make-laten read <file>");
+    console.log("  make-laten grep <pattern>");
+    console.log("  make-laten git diff");
+    return;
+  }
+  for (const name of installed) {
+    console.log(`  \u2713 ${name} configured`);
+  }
+  for (const name of skipped) {
+    console.log(`  \u25CB ${name} skipped (already configured or unavailable)`);
+  }
+  console.log(`
+Done! Configured for ${installed.length} agent(s).`);
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("make-laten").description("Universal efficiency skill for AI coding agents").version("0.1.0");
+program.command("read").description("Compressed file read").argument("<file>", "File path").action(readCommand);
+program.command("grep").description("Compressed grep with file grouping").argument("<pattern>", "Search pattern").argument("[directory]", "Directory to search", ".").option("-i, --ignore <ext>", "File extension to ignore").action(grepCommand);
+var gitCmd = program.command("git").description("Git operations");
+gitCmd.command("diff").description("Compressed git diff").option("-s, --staged", "Show staged changes").action(gitDiffCommand);
+gitCmd.command("status").description("Git status summary").action(gitStatusCommand);
+var cacheCmd = program.command("cache").description("Cache management");
+cacheCmd.command("stats").description("Show cache statistics").action(cacheStatsCommand);
+cacheCmd.command("clear").description("Clear cache").action(cacheClearCommand);
+program.command("search").description("Search the web").argument("<query>", "Search query").option("-b, --backend <backend>", "Search backend").option("-m, --max <n>", "Max results", "5").action(searchCommand);
+program.command("fetch").description("Fetch and compress web content").argument("<url>", "URL to fetch").option("--no-compress", "Disable compression").option("--no-extract", "Disable semantic extraction").action(fetchCommand);
+program.command("install").description("Install make-laten adapters for detected agents").option("-u, --uninstall", "Remove adapters").option("-s, --status", "Show installation status").action(installCommand);
+program.parse();
+//# sourceMappingURL=index.mjs.map