make-laten 1.1.0 → 1.2.0

package/dist/cli/index.js

@@ -58,29 +58,145 @@ function isKnownPattern(content) {
   return patterns.some((p) => p.test(content));
 }
 
+// src/compress/strip.ts
+function stripImports(content) {
+  return content.replace(/^import\s+[\s\S]*?from\s+['"][^'"]+['"]\s*;?\s*$/gm, "").replace(/^import\s+['"][^'"]+['"]\s*;?\s*$/gm, "").replace(/^import\s+\{[^}]*\}\s+from\s+['"][^'"]+['"]\s*;?\s*$/gm, "").split("\n").filter((l) => l.trim() !== "").join("\n");
+}
+function stripComments(content) {
+  let result = content.replace(/(?<!["'`])\/\/.*$/gm, "");
+  result = result.replace(/\/\*[\s\S]*?\*\//g, "");
+  return result.split("\n").filter((l) => l.trim() !== "").join("\n");
+}
+function stripBlankLines(content) {
+  return content.replace(/\n{3,}/g, "\n\n");
+}
+function stripWhitespace(content) {
+  return content.replace(/[ \t]+$/gm, "");
+}
+function stripAll(content) {
+  let result = content;
+  result = stripImports(result);
+  result = stripComments(result);
+  result = stripBlankLines(result);
+  result = stripWhitespace(result);
+  return result.trim();
+}
+
+// src/compress/structure.ts
+function extractExports(content) {
+  const lines = content.split("\n");
+  const exports2 = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^export\s+(default\s+)?/.test(trimmed)) {
+      if (trimmed.includes("{") && !trimmed.includes("}")) {
+        exports2.push(trimmed.replace(/\{[\s\S]*$/, "{ ... }"));
+      } else {
+        exports2.push(trimmed);
+      }
+    }
+  }
+  return exports2.join("\n");
+}
+function extractClassMethods(content) {
+  const classRegex = /class\s+\w+[^{]*\{([\s\S]*?)\n\}/g;
+  const methods = [];
+  let match;
+  while ((match = classRegex.exec(content)) !== null) {
+    const classBody = match[1];
+    const methodRegex = /(^\s*(?:public|private|protected|static|async|abstract|\s)*\w+\s*\([^)]*\)(?:\s*:\s*[^{]+)?)\s*\{/gm;
+    let methodMatch;
+    while ((methodMatch = methodRegex.exec(classBody)) !== null) {
+      methods.push(methodMatch[1].trim());
+    }
+  }
+  return methods.join("\n");
+}
+function extractFunctionSignatures(content) {
+  const funcRegex = /(export\s+)?(async\s+)?function\s+\w+\s*\([^)]*\)(?:\s*:\s*[^{]+)?\s*\{/g;
+  const signatures = [];
+  let match;
+  while ((match = funcRegex.exec(content)) !== null) {
+    signatures.push(match[0].replace(/\{$/, ""));
+  }
+  return signatures.join("\n");
+}
+function extractTypeDefinitions(content) {
+  const typeRegex = /(export\s+)?(interface|type)\s+\w+[^{]*\{[^}]*\}|(export\s+)?type\s+\w+\s*=[^;]+;?/g;
+  const types = [];
+  let match;
+  while ((match = typeRegex.exec(content)) !== null) {
+    types.push(match[0].trim());
+  }
+  return types.join("\n");
+}
+
+// src/compress/truncate.ts
+function smartTruncate(content, maxTokens) {
+  const lines = content.split("\n");
+  const estimatedTokens = Math.ceil(content.length / 4);
+  if (estimatedTokens <= maxTokens) return content;
+  const targetLines = Math.round(maxTokens * 4 / (content.length / lines.length));
+  const headerLines = Math.floor(targetLines * 0.3);
+  const footerLines = Math.floor(targetLines * 0.3);
+  const omitted = lines.length - headerLines - footerLines;
+  const header = lines.slice(0, headerLines);
+  const footer = lines.slice(-footerLines);
+  return [...header, `
+... [${omitted} lines omitted] ...
+`, ...footer].join("\n");
+}
+
 // src/compress/file-read.ts
 var FileReadCompressor = class {
   async compress(input) {
     const { content, filePath, language } = input;
-    const signatures = this.extractSignatures(content, language);
-    const exports2 = this.extractExports(content);
-    const lines = [
+    const lines = content.split("\n").length;
+    const tokens = Math.ceil(content.length / 4);
+    if (tokens < 200) {
+      return {
+        content,
+        original: content,
+        confidence: 1,
+        metadata: {
+          strategy: "passthrough",
+          originalLines: lines,
+          compressedLines: lines,
+          savings: 0
+        }
+      };
+    }
+    const stripped = stripAll(content);
+    const exports2 = extractExports(stripped);
+    const classes = extractClassMethods(stripped);
+    const functions = extractFunctionSignatures(stripped);
+    const types = extractTypeDefinitions(stripped);
+    const sections = [
       `// ${filePath} (${content.split("\n").length} lines)`,
       "",
-      ...signatures,
-      "",
       "// Exports:",
-      ...exports2
-    ];
-    const compressed = lines.join("\n");
+      exports2,
+      "",
+      "// Classes:",
+      classes,
+      "",
+      "// Functions:",
+      functions,
+      "",
+      "// Types:",
+      types
+    ].filter((l) => l !== "" && !l.endsWith(":"));
+    let compressed = sections.join("\n");
+    const maxTokens = 2e3;
+    compressed = smartTruncate(compressed, maxTokens);
     return {
       content: compressed,
       original: content,
       confidence: calculateConfidence(content, compressed),
       metadata: {
-        strategy: "signatures",
+        strategy: "hybrid",
         originalLines: content.split("\n").length,
-        compressedLines: lines.length,
+        compressedLines: compressed.split("\n").length,
         savings: 1 - compressed.length / content.length
       }
     };
@@ -88,32 +204,6 @@ var FileReadCompressor = class {
   async decompress(compressed) {
     return compressed.original;
   }
-  extractSignatures(content, language) {
-    const signatures = [];
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (/^(export\s+)?(async\s+)?function\s+\w+/.test(trimmed)) {
-        signatures.push(trimmed.replace(/\{[\s\S]*$/, "{ ... }"));
-      }
-      if (/^(export\s+)?class\s+\w+/.test(trimmed)) {
-        signatures.push(trimmed);
-      }
-      if (/^(export\s+)?(type|interface)\s+\w+/.test(trimmed)) {
-        signatures.push(trimmed);
-      }
-    }
-    return signatures;
-  }
-  extractExports(content) {
-    const exports2 = [];
-    const exportRegex = /export\s+(default\s+)?(function|class|const|let|var|type|interface)\s+(\w+)/g;
-    let match;
-    while ((match = exportRegex.exec(content)) !== null) {
-      exports2.push(`  - ${match[3]} (${match[2]})`);
-    }
-    return exports2;
-  }
 };
 
 // src/cli/commands/read.ts
@@ -272,18 +362,21 @@ var import_util2 = require("util");
 var GitDiffCompressor = class {
   async compress(input) {
     const { diff } = input;
-    const hunks = this.parseDiff(diff);
-    const condensed = hunks.map((hunk) => ({
-      file: hunk.file,
-      changes: this.condenseHunk(hunk),
-      stats: { additions: hunk.additions, deletions: hunk.deletions }
-    }));
+    const files = this.parseDiff(diff);
     const lines = [];
-    for (const hunk of condensed) {
-      if (hunk.changes.length > 0) {
-        lines.push(`${hunk.file} (+${hunk.stats.additions} -${hunk.stats.deletions})`);
-        lines.push(...hunk.changes);
+    const totalAdd = files.reduce((s, f) => s + f.additions, 0);
+    const totalDel = files.reduce((s, f) => s + f.deletions, 0);
+    lines.push(`# ${files.length} files changed: +${totalAdd} -${totalDel}`);
+    lines.push("");
+    for (const file of files) {
+      lines.push(`${file.path} (+${file.additions} -${file.deletions})`);
+      const changes = file.lines.filter((l) => l.type === "add" || l.type === "del").map((l) => `${l.type === "add" ? "+" : "-"}${l.content}`);
+      const limited = changes.slice(0, 20);
+      lines.push(...limited);
+      if (changes.length > 20) {
+        lines.push(`... [${changes.length - 20} more changes]`);
       }
+      lines.push("");
     }
     const compressed = lines.join("\n");
     return {
@@ -292,7 +385,7 @@ var GitDiffCompressor = class {
       confidence: calculateConfidence(diff, compressed),
       metadata: {
         strategy: "condensed",
-        filesChanged: condensed.length,
+        filesChanged: files.length,
         savings: 1 - compressed.length / diff.length
       }
     };
@@ -301,34 +394,31 @@ var GitDiffCompressor = class {
     return compressed.original;
   }
   parseDiff(diff) {
-    const hunks = [];
+    const files = [];
     const lines = diff.split("\n");
-    let currentHunk = null;
+    let current = null;
     for (const line of lines) {
       if (line.startsWith("diff --git")) {
-        if (currentHunk) hunks.push(currentHunk);
-        const fileMatch = line.match(/b\/(.+)/);
-        currentHunk = {
-          file: fileMatch?.[1] || "unknown",
-          lines: [],
+        if (current) files.push(current);
+        const match = line.match(/b\/(.+)/);
+        current = {
+          path: match?.[1] || "unknown",
           additions: 0,
-          deletions: 0
+          deletions: 0,
+          lines: []
         };
-      } else if (currentHunk) {
+      } else if (current) {
         if (line.startsWith("+")) {
-          currentHunk.additions++;
-          currentHunk.lines.push({ type: "addition", content: line.slice(1) });
+          current.additions++;
+          current.lines.push({ type: "add", content: line.slice(1) });
         } else if (line.startsWith("-")) {
-          currentHunk.deletions++;
-          currentHunk.lines.push({ type: "deletion", content: line.slice(1) });
+          current.deletions++;
+          current.lines.push({ type: "del", content: line.slice(1) });
         }
       }
     }
-    if (currentHunk) hunks.push(currentHunk);
-    return hunks;
-  }
-  condenseHunk(hunk) {
-    return hunk.lines.filter((l) => l.type === "addition" || l.type === "deletion").map((l) => `${l.type === "addition" ? "+" : "-"} ${l.content}`);
+    if (current) files.push(current);
+    return files;
   }
 };
 
@@ -1349,125 +1439,102 @@ async function directoryExists(dirPath) {
     return false;
   }
 }
+async function readJSON(filePath) {
+  try {
+    const raw = await import_promises3.default.readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function writeJSON(filePath, data) {
+  try {
+    const dir = import_path2.default.dirname(filePath);
+    await import_promises3.default.mkdir(dir, { recursive: true });
+    await import_promises3.default.writeFile(filePath, JSON.stringify(data, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var MCP_CMD = ["npx", "-y", "make-laten-mcp", "server"];
 async function detectAllAgents() {
   const home = getHome2();
   const agents2 = [];
-  const claudeConfig = import_path2.default.join(home, ".claude", "mcp.json");
-  const claudeDir = import_path2.default.join(home, ".claude");
   agents2.push({
     name: "Claude Code",
-    detected: await commandExists2("claude") || await directoryExists(claudeDir),
-    configPath: claudeConfig,
-    mcpConfig: {
-      mcpServers: {
-        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
-      }
-    },
-    version: await commandExists2("claude") ? await execAsync4("claude --version", { timeout: 3e3 }).then((r) => r.stdout.trim().split("\n")[0]).catch(() => "unknown") : void 0
+    detected: await commandExists2("claude") || await directoryExists(import_path2.default.join(home, ".claude")),
+    configPath: import_path2.default.join(home, ".claude", "mcp.json"),
+    version: await commandExists2("claude") ? await execAsync4("claude --version", { timeout: 3e3 }).then((r) => r.stdout.trim().split("\n")[0]).catch(() => "unknown") : void 0,
+    writeConfig: async (p) => {
+      const data = await readJSON(p);
+      data.mcpServers = { ...data.mcpServers || {}, "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] } };
+      return writeJSON(p, data);
+    }
   });
-  const cursorMcp = import_path2.default.join(home, ".cursor", "mcp.json");
-  const cursorDir = import_path2.default.join(home, ".cursor");
   agents2.push({
     name: "Cursor",
-    detected: await directoryExists(cursorDir),
-    configPath: cursorMcp,
-    mcpConfig: {
-      mcpServers: {
-        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
-      }
+    detected: await directoryExists(import_path2.default.join(home, ".cursor")),
+    configPath: import_path2.default.join(home, ".cursor", "mcp.json"),
+    writeConfig: async (p) => {
+      const data = await readJSON(p);
+      data.mcpServers = { ...data.mcpServers || {}, "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] } };
+      return writeJSON(p, data);
     }
   });
-  const codexMcp = import_path2.default.join(home, ".codex", "config.json");
-  const codexDir = import_path2.default.join(home, ".codex");
   agents2.push({
     name: "Codex",
-    detected: await commandExists2("codex") || await directoryExists(codexDir),
-    configPath: codexMcp,
-    mcpConfig: {
-      mcpServers: {
-        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
-      }
+    detected: await commandExists2("codex") || await directoryExists(import_path2.default.join(home, ".codex")),
+    configPath: import_path2.default.join(home, ".codex", "config.json"),
+    writeConfig: async (p) => {
+      const data = await readJSON(p);
+      data.mcpServers = { ...data.mcpServers || {}, "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] } };
+      return writeJSON(p, data);
     }
   });
-  const windsurfMcp = import_path2.default.join(home, ".codeium", "windsurf", "mcp_config.json");
-  const windsurfDir = import_path2.default.join(home, ".codeium", "windsurf");
   agents2.push({
-    name: "Windsurf",
-    detected: await directoryExists(windsurfDir),
-    configPath: windsurfMcp,
-    mcpConfig: {
-      mcpServers: {
-        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
-      }
+    name: "OpenCode",
+    detected: await directoryExists(import_path2.default.join(home, ".config", "opencode")),
+    configPath: import_path2.default.join(home, ".config", "opencode", "opencode.json"),
+    writeConfig: async (p) => {
+      const data = await readJSON(p);
+      data.mcp = { ...data.mcp || {}, "make-laten": { type: "local", command: MCP_CMD, enabled: true } };
+      delete data.mcpServers;
+      return writeJSON(p, data);
     }
   });
-  const openCodeConfig = import_path2.default.join(home, ".config", "opencode", "opencode.json");
-  const openCodeDir = import_path2.default.join(home, ".config", "opencode");
   agents2.push({
-    name: "OpenCode",
-    detected: await directoryExists(openCodeDir),
-    configPath: openCodeConfig,
-    mcpConfig: {
-      mcpServers: {
-        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
-      }
+    name: "Windsurf",
+    detected: await directoryExists(import_path2.default.join(home, ".codeium", "windsurf")),
+    configPath: import_path2.default.join(home, ".codeium", "windsurf", "mcp_config.json"),
+    writeConfig: async (p) => {
+      const data = await readJSON(p);
+      data.mcpServers = { ...data.mcpServers || {}, "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] } };
+      return writeJSON(p, data);
     }
   });
-  const clineDir = import_path2.default.join(home, ".cline");
-  const clineMcp = import_path2.default.join(home, ".cline", "mcp_settings.json");
   agents2.push({
     name: "Cline",
-    detected: await directoryExists(clineDir),
-    configPath: clineMcp,
-    mcpConfig: {
-      mcpServers: {
-        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
-      }
+    detected: await directoryExists(import_path2.default.join(home, ".cline")),
+    configPath: import_path2.default.join(home, ".cline", "mcp_settings.json"),
+    writeConfig: async (p) => {
+      const data = await readJSON(p);
+      data.mcpServers = { ...data.mcpServers || {}, "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] } };
+      return writeJSON(p, data);
     }
   });
-  const vscodeDir = import_path2.default.join(home, "Library", "Application Support", "Code", "User", "globalStorage");
-  agents2.push({
-    name: "GitHub Copilot (VS Code)",
-    detected: await directoryExists(vscodeDir),
-    configPath: "",
-    mcpConfig: {}
-  });
-  const geminiDir = import_path2.default.join(home, ".gemini");
   agents2.push({
     name: "Gemini CLI",
-    detected: await commandExists2("gemini") || await directoryExists(geminiDir),
+    detected: await commandExists2("gemini") || await directoryExists(import_path2.default.join(home, ".gemini")),
     configPath: import_path2.default.join(home, ".gemini", "settings.json"),
-    mcpConfig: {
-      mcpServers: {
-        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
-      }
+    writeConfig: async (p) => {
+      const data = await readJSON(p);
+      data.mcpServers = { ...data.mcpServers || {}, "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] } };
+      return writeJSON(p, data);
     }
   });
   return agents2;
 }
-async function writeMCPConfig(agent) {
-  try {
-    const dir = import_path2.default.dirname(agent.configPath);
-    await import_promises3.default.mkdir(dir, { recursive: true });
-    let existing = {};
-    try {
-      const raw = await import_promises3.default.readFile(agent.configPath, "utf-8");
-      existing = JSON.parse(raw);
-    } catch {
-    }
-    const merged = {
-      ...existing,
-      mcpServers: {
-        ...existing.mcpServers || {},
-        ...agent.mcpConfig.mcpServers
-      }
-    };
-    await import_promises3.default.writeFile(agent.configPath, JSON.stringify(merged, null, 2));
-    return true;
-  } catch {
-    return false;
-  }
-}
 function askQuestion(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
@@ -1494,42 +1561,25 @@ async function initCommand(options) {
   console.log("");
   if (options.all) {
     for (const agent of detected) {
-      const success = await writeMCPConfig(agent);
+      const success = await agent.writeConfig(agent.configPath);
       if (success) {
         console.log(`    \u2713 ${agent.name} \u2192 MCP configured`);
       } else {
-        console.log(`    \u2717 ${agent.name} \u2192 failed`);
+        console.log(`    \u2717 ${agent.name} \u2192 failed to write config`);
       }
     }
   } else if (options.project) {
     const cwd = process.cwd();
-    const mcpConfig = {
-      mcpServers: {
-        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
-      }
-    };
     const configPath = import_path2.default.join(cwd, ".mcp.json");
-    let existing = {};
-    try {
-      const raw = await import_promises3.default.readFile(configPath, "utf-8");
-      existing = JSON.parse(raw);
-    } catch {
-    }
-    const merged = {
-      ...existing,
-      mcpServers: {
-        ...existing.mcpServers || {},
-        ...mcpConfig.mcpServers
-      }
-    };
-    await import_promises3.default.writeFile(configPath, JSON.stringify(merged, null, 2));
+    const data = { mcpServers: { "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] } } };
+    await writeJSON(configPath, data);
     console.log(`    \u2713 .mcp.json created in ${cwd}`);
   } else {
     const rl = import_readline.default.createInterface({ input: process.stdin, output: process.stdout });
     for (const agent of detected) {
       const answer = await askQuestion(rl, `    Configure ${agent.name}? (Y/n) `);
       if (answer.toLowerCase() !== "n") {
-        const success = await writeMCPConfig(agent);
+        const success = await agent.writeConfig(agent.configPath);
         if (success) {
           console.log(`      \u2713 ${agent.name} \u2192 MCP configured`);
         } else {
@@ -1553,6 +1603,156 @@ async function initCommand(options) {
   console.log("");
 }
 
+// src/compress/git-status.ts
+var GitStatusCompressor = class {
+  async compress(input) {
+    const { status } = input;
+    const statusLines = status.split("\n").filter(Boolean).length;
+    const tokens = Math.ceil(status.length / 4);
+    if (tokens < 10) {
+      return {
+        content: status,
+        original: status,
+        confidence: 1,
+        metadata: {
+          strategy: "passthrough",
+          totalFiles: statusLines,
+          savings: 0
+        }
+      };
+    }
+    const files = this.parseStatus(status);
+    const grouped = this.groupByStatus(files);
+    const lines = [];
+    for (const [statusType, statusFiles] of grouped) {
+      const label = this.statusLabel(statusType);
+      lines.push(`${label} (${statusFiles.length})`);
+      const compressed2 = this.compressPaths(statusFiles.map((f) => f.path));
+      lines.push(...compressed2);
+      lines.push("");
+    }
+    const compressed = lines.join("\n");
+    return {
+      content: compressed,
+      original: status,
+      confidence: calculateConfidence(status, compressed),
+      metadata: {
+        strategy: "grouped",
+        totalFiles: files.length,
+        savings: 1 - compressed.length / status.length
+      }
+    };
+  }
+  async decompress(compressed) {
+    return compressed.original;
+  }
+  parseStatus(status) {
+    return status.split("\n").filter(Boolean).map((line) => {
+      const match = line.match(/^(\?\?|[MADRC]+\s+)(.+)$/);
+      if (match) {
+        return { status: match[1].trim(), path: match[2] };
+      }
+      return { status: line[0], path: line.slice(3) };
+    });
+  }
+  groupByStatus(files) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const existing = grouped.get(file.status) || [];
+      existing.push(file);
+      grouped.set(file.status, existing);
+    }
+    return grouped;
+  }
+  statusLabel(status) {
+    const labels = {
+      "M": "Modified",
+      "A": "Added",
+      "D": "Deleted",
+      "??": "Untracked",
+      "R": "Renamed"
+    };
+    return labels[status] || `Status ${status}`;
+  }
+  compressPaths(paths) {
+    if (paths.length <= 3) return paths.map((p) => `  ${p}`);
+    const parts = paths.map((p) => p.split("/"));
+    const minLength = Math.min(...parts.map((p) => p.length));
+    let commonIndex = 0;
+    for (let i = 0; i < minLength; i++) {
+      if (parts.every((p) => p[i] === parts[0][i])) {
+        commonIndex = i;
+      } else {
+        break;
+      }
+    }
+    if (commonIndex > 0) {
+      const prefix = parts[0].slice(0, commonIndex).join("/");
+      const suffixes = paths.map((p) => p.slice(prefix.length + 1));
+      return [`  ${prefix}/`, ...suffixes.map((s) => `    ${s}`)];
+    }
+    return paths.map((p) => `  ${p}`);
+  }
+};
+
+// src/cli/commands/benchmark.ts
+var import_fs = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
+async function benchmark() {
+  const fileCompressor = new FileReadCompressor();
+  const diffCompressor = new GitDiffCompressor();
+  const statusCompressor = new GitStatusCompressor();
+  const projectPath = process.cwd();
+  console.log("");
+  console.log("  make-laten benchmark");
+  console.log("  ===================");
+  console.log("");
+  const results = [];
+  const testFiles = ["src/index.ts", "package.json", "README.md", "src/mcp/server.ts"];
+  for (const file of testFiles) {
+    const full = import_path3.default.join(projectPath, file);
+    if (!import_fs.default.existsSync(full)) continue;
+    const content = import_fs.default.readFileSync(full, "utf-8");
+    const raw = Math.round(content.length / 4);
+    const result = await fileCompressor.compress({ content, filePath: file });
+    const compressed = Math.round(result.content.length / 4);
+    results.push({ name: `read ${file}`, raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
+  }
+  try {
+    const diff = (0, import_child_process5.execSync)('git diff HEAD~1 2>/dev/null || echo ""', { cwd: projectPath, encoding: "utf-8" }).trim();
+    if (diff) {
+      const raw = Math.round(diff.length / 4);
+      const result = await diffCompressor.compress({ diff });
+      const compressed = Math.round(result.content.length / 4);
+      results.push({ name: "git-diff", raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
+    }
+  } catch {
+  }
+  try {
+    const status = (0, import_child_process5.execSync)('git status --porcelain 2>/dev/null || echo ""', { cwd: projectPath, encoding: "utf-8" }).trim();
+    if (status) {
+      const raw = Math.round(status.length / 4);
+      const result = await statusCompressor.compress({ status });
+      const compressed = Math.round(result.content.length / 4);
+      results.push({ name: "git-status", raw, compressed, savings: Math.round((1 - compressed / raw) * 100) });
+    }
+  } catch {
+  }
+  console.log("  Command".padEnd(28) + "Raw".padEnd(10) + "Compressed".padEnd(12) + "Savings");
+  console.log("  " + "\u2500".repeat(60));
+  for (const r of results) {
+    console.log(`  ${r.name}`.padEnd(28) + `${r.raw}`.padEnd(10) + `${r.compressed}`.padEnd(12) + `${r.savings}%`);
+  }
+  const totalRaw = results.reduce((s, r) => s + r.raw, 0);
+  const totalCompressed = results.reduce((s, r) => s + r.compressed, 0);
+  const savings = Math.round((1 - totalCompressed / totalRaw) * 100);
+  console.log("");
+  console.log(`  Total: ${totalRaw} \u2192 ${totalCompressed} tokens (${savings}% saved)`);
+  console.log("");
+}
+benchmark();
+
 // src/cli/index.ts
 var program = new import_commander.Command();
 program.name("make-laten").description("Universal efficiency toolkit for AI coding agents").version("1.0.3");
@@ -1568,5 +1768,6 @@ program.command("search").description("Search the web").argument("<query>", "Sea
 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 across all detected platforms").option("-u, --uninstall", "Remove adapters").option("-s, --status", "Show installation status").action(installCommand);
 program.command("init").description("Interactive setup wizard \u2014 detect agents & configure MCP").option("-a, --all", "Configure all detected agents (no prompts)").option("-p, --project", "Create .mcp.json in current directory only").action(initCommand);
+program.command("benchmark").description("Compare raw vs compressed output").action(void 0);
 program.parse();
 //# sourceMappingURL=index.js.map