make-laten 1.0.1 → 1.1.0

package/dist/cli/index.js

@@ -938,260 +938,310 @@ async function fetchCommand(url, options) {
   }
 }
 
-// src/adapter/detector.ts
-var import_child_process3 = require("child_process");
-var import_util3 = require("util");
+// src/adapter/installer.ts
 var import_promises2 = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
+var import_child_process3 = require("child_process");
+var import_util3 = require("util");
+var execAsync3 = (0, import_util3.promisify)(import_child_process3.exec);
+var RULES_CONTENT = `
+# make-laten efficiency rules
 
-// 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" }
-};
+## Token Optimization
+- When reading files, use \`make-laten read <file>\` for compressed output
+- When searching code, use \`make-laten grep <pattern>\` for grouped results
+- When checking git, use \`make-laten git diff\` for condensed output
+- When fetching web, use \`make-laten fetch <url>\` for compressed content
 
-// src/adapter/detector.ts
-var execAsync3 = (0, import_util3.promisify)(import_child_process3.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;
+## Quick Commands
+- \`mread <file>\` \u2014 alias for make-laten read
+- \`mgrep <pattern>\` \u2014 alias for make-laten grep
+- \`mdiff\` \u2014 alias for make-laten git diff
+- \`msearch <query>\` \u2014 alias for make-laten search
+- \`mfetch <url>\` \u2014 alias for make-laten fetch
+`;
+function getHome() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+async function commandExists(cmd) {
+  try {
+    await execAsync3(`which ${cmd}`, { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
   }
-  async detectAgent(name, type) {
-    const commands = {
-      "claude-code": "claude --version",
-      "codex": "codex --version",
-      "gemini-cli": "gemini --version"
-    };
-    if (commands[name]) {
+}
+var agents = [
+  {
+    name: "terminal (shell aliases)",
+    detected: async () => true,
+    install: async () => {
+      const shellInit = await execAsync3("echo $SHELL").then((r) => r.stdout.trim());
+      const rcFile = shellInit.includes("zsh") ? ".zshrc" : ".bashrc";
+      const rcPath = import_path.default.join(getHome(), rcFile);
+      const marker = "make-laten shell";
+      let existing = "";
       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 };
+        existing = await import_promises2.default.readFile(rcPath, "utf-8");
       } catch {
-        return null;
       }
-    }
-    if (type === "rules") {
-      const rulesPath = AGENT_CONFIGS[name]?.rulesFile;
-      if (rulesPath) {
-        try {
-          await import_promises2.default.access(import_path.default.join(process.cwd(), rulesPath));
-          return { name, type, path: process.cwd(), version: null, detected: true };
-        } catch {
-          return null;
-        }
+      if (!existing.includes(marker)) {
+        const npmRoot = await execAsync3("npm root -g").then((r) => r.stdout.trim());
+        const initScript = `
+# make-laten shell integration
+source ${npmRoot}/make-laten/shell/init.sh
+`;
+        await import_promises2.default.appendFile(rcPath, initScript);
+      }
+    },
+    uninstall: async () => {
+      const shellInit = await execAsync3("echo $SHELL").then((r) => r.stdout.trim());
+      const rcFile = shellInit.includes("zsh") ? ".zshrc" : ".bashrc";
+      const rcPath = import_path.default.join(getHome(), rcFile);
+      try {
+        let content = await import_promises2.default.readFile(rcPath, "utf-8");
+        content = content.replace(/\n# make-laten shell integration\nsource .*\/make-laten\/shell\/init\.sh\n/g, "");
+        await import_promises2.default.writeFile(rcPath, content);
+      } catch {
       }
     }
-    return null;
-  }
-  async getAgentPath(name) {
-    const home = process.env.HOME || process.env.USERPROFILE || "";
-    const paths = {
-      "claude-code": import_path.default.join(home, ".claude"),
-      "codex": import_path.default.join(home, ".codex"),
-      "gemini-cli": import_path.default.join(home, ".gemini")
-    };
-    return paths[name] || import_path.default.join(home, `.${name}`);
-  }
-  async hasCommand(cmd) {
-    try {
-      await execAsync3(`which ${cmd}`, { timeout: 3e3 });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// src/adapter/hook.ts
-var import_promises3 = __toESM(require("fs/promises"));
-var import_path2 = __toESM(require("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 = import_path2.default.join(agentPath, "hooks");
-    await import_promises3.default.mkdir(hooksDir, { recursive: true });
-    const preToolHook = `#!/usr/bin/env node
+  },
+  {
+    name: "claude-code",
+    detected: async () => commandExists("claude"),
+    install: async () => {
+      const hooksDir = import_path.default.join(getHome(), ".claude", "hooks");
+      await import_promises2.default.mkdir(hooksDir, { recursive: true });
+      const preHook = `#!/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
+process.stdout.write(JSON.stringify(input));`;
+      const postHook = `#!/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 import_promises3.default.writeFile(import_path2.default.join(hooksDir, "pre-tool-use.js"), preToolHook);
-    await import_promises3.default.writeFile(import_path2.default.join(hooksDir, "post-tool-use.js"), postToolHook);
-  }
-  async uninstall(agentPath) {
-    const hooksDir = import_path2.default.join(agentPath, "hooks");
-    try {
-      await import_promises3.default.rm(import_path2.default.join(hooksDir, "pre-tool-use.js"), { force: true });
-      await import_promises3.default.rm(import_path2.default.join(hooksDir, "post-tool-use.js"), { force: true });
-    } catch {
+process.stdout.write(JSON.stringify(input));`;
+      await import_promises2.default.writeFile(import_path.default.join(hooksDir, "pre-tool-use.js"), preHook);
+      await import_promises2.default.writeFile(import_path.default.join(hooksDir, "post-tool-use.js"), postHook);
+    },
+    uninstall: async () => {
+      const hooksDir = import_path.default.join(getHome(), ".claude", "hooks");
+      try {
+        await import_promises2.default.rm(import_path.default.join(hooksDir, "pre-tool-use.js"), { force: true });
+      } catch {
+      }
+      try {
+        await import_promises2.default.rm(import_path.default.join(hooksDir, "post-tool-use.js"), { force: true });
+      } catch {
+      }
     }
-  }
-  async isInstalled(agentPath) {
-    try {
-      await import_promises3.default.access(import_path2.default.join(agentPath, "hooks", "pre-tool-use.js"));
-      return true;
-    } catch {
-      return false;
+  },
+  {
+    name: "cursor",
+    detected: async () => {
+      try {
+        await import_promises2.default.access(import_path.default.join(getHome(), ".cursor"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const rulesDir = import_path.default.join(getHome(), ".cursor", "rules");
+      await import_promises2.default.mkdir(rulesDir, { recursive: true });
+      const ruleFile = import_path.default.join(rulesDir, "make-laten.mdc");
+      const content = `---
+description: make-laten efficiency rules
+globs:
+---
+${RULES_CONTENT}`;
+      await import_promises2.default.writeFile(ruleFile, content);
+    },
+    uninstall: async () => {
+      try {
+        await import_promises2.default.rm(import_path.default.join(getHome(), ".cursor", "rules", "make-laten.mdc"), { force: true });
+      } catch {
+      }
     }
-  }
-};
-
-// src/adapter/rules.ts
-var import_promises4 = __toESM(require("fs/promises"));
-var import_path3 = __toESM(require("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}`);
+  },
+  {
+    name: "codex",
+    detected: async () => commandExists("codex"),
+    install: async () => {
+      const agentsMd = import_path.default.join(process.cwd(), "AGENTS.md");
+      let existing = "";
+      try {
+        existing = await import_promises2.default.readFile(agentsMd, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        const content = existing + "\n\n## make-laten Integration\n" + RULES_CONTENT;
+        await import_promises2.default.writeFile(agentsMd, content);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await import_promises2.default.readFile(import_path.default.join(process.cwd(), "AGENTS.md"), "utf-8");
+        content = content.replace(/\n## make-laten Integration[\s\S]*$/, "");
+        await import_promises2.default.writeFile(import_path.default.join(process.cwd(), "AGENTS.md"), content.trim() + "\n");
+      } catch {
+      }
     }
-    const rulesPath = import_path3.default.join(agentPath, config.rulesFile);
-    const existing = await import_promises4.default.readFile(rulesPath, "utf-8").catch(() => "");
-    if (existing.includes("make-laten")) {
-      return;
+  },
+  {
+    name: "windsurf",
+    detected: async () => {
+      try {
+        await import_promises2.default.access(import_path.default.join(process.cwd(), ".windsurf"));
+        return true;
+      } catch {
+        try {
+          await import_promises2.default.access(import_path.default.join(getHome(), ".windsurf"));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    },
+    install: async () => {
+      const rulesPath = import_path.default.join(process.cwd(), ".windsurfrules");
+      let existing = "";
+      try {
+        existing = await import_promises2.default.readFile(rulesPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await import_promises2.default.writeFile(rulesPath, existing + "\n\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await import_promises2.default.readFile(import_path.default.join(process.cwd(), ".windsurfrules"), "utf-8");
+        content = content.replace(/\n# make-laten efficiency rules[\s\S]*$/, "");
+        await import_promises2.default.writeFile(import_path.default.join(process.cwd(), ".windsurfrules"), content.trim() + "\n");
+      } catch {
+      }
     }
-    await import_promises4.default.mkdir(import_path3.default.dirname(rulesPath), { recursive: true });
-    await import_promises4.default.writeFile(rulesPath, existing + "\n\n" + RULES_TEMPLATE);
-  }
-  async uninstall(agentPath) {
-    const config = AGENT_CONFIGS[this.name];
-    if (!config?.rulesFile) return;
-    const rulesPath = import_path3.default.join(agentPath, config.rulesFile);
-    try {
-      let content = await import_promises4.default.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 import_promises4.default.writeFile(rulesPath, content.trim() + "\n");
+  },
+  {
+    name: "cline",
+    detected: async () => {
+      try {
+        await import_promises2.default.access(import_path.default.join(process.cwd(), ".clinerules"));
+        return true;
+      } catch {
+        try {
+          await import_promises2.default.access(import_path.default.join(getHome(), ".cline"));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    },
+    install: async () => {
+      const rulesPath = import_path.default.join(process.cwd(), ".clinerules");
+      let existing = "";
+      try {
+        existing = await import_promises2.default.readFile(rulesPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await import_promises2.default.writeFile(rulesPath, existing + "\n\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await import_promises2.default.readFile(import_path.default.join(process.cwd(), ".clinerules"), "utf-8");
+        content = content.replace(/\n# make-laten efficiency rules[\s\S]*$/, "");
+        await import_promises2.default.writeFile(import_path.default.join(process.cwd(), ".clinerules"), content.trim() + "\n");
+      } catch {
       }
-    } catch {
     }
-  }
-  async isInstalled(agentPath) {
-    const config = AGENT_CONFIGS[this.name];
-    if (!config?.rulesFile) return false;
-    try {
-      const content = await import_promises4.default.readFile(import_path3.default.join(agentPath, config.rulesFile), "utf-8");
-      return content.includes("make-laten");
-    } catch {
-      return false;
+  },
+  {
+    name: "copilot",
+    detected: async () => {
+      try {
+        await import_promises2.default.access(import_path.default.join(process.cwd(), ".github"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const dir = import_path.default.join(process.cwd(), ".github");
+      await import_promises2.default.mkdir(dir, { recursive: true });
+      const instructionsPath = import_path.default.join(dir, "copilot-instructions.md");
+      let existing = "";
+      try {
+        existing = await import_promises2.default.readFile(instructionsPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await import_promises2.default.writeFile(instructionsPath, existing + "\n\n## make-laten Efficiency\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await import_promises2.default.readFile(import_path.default.join(process.cwd(), ".github", "copilot-instructions.md"), "utf-8");
+        content = content.replace(/\n## make-laten Efficiency[\s\S]*$/, "");
+        await import_promises2.default.writeFile(import_path.default.join(process.cwd(), ".github", "copilot-instructions.md"), content.trim() + "\n");
+      } catch {
+      }
     }
-  }
-};
+  },
+  {
+    name: "opencode",
+    detected: async () => {
+      try {
+        await import_promises2.default.access(import_path.default.join(getHome(), ".config", "opencode"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const skillsDir = import_path.default.join(getHome(), ".config", "opencode", "skills", "make-laten");
+      await import_promises2.default.mkdir(skillsDir, { recursive: true });
+      const npmRoot = await execAsync3("npm root -g").then((r) => r.stdout.trim());
+      const skillSrc = import_path.default.join(npmRoot, "make-laten", "skills", "SKILL.md");
+      try {
+        const skillContent = await import_promises2.default.readFile(skillSrc, "utf-8");
+        await import_promises2.default.writeFile(import_path.default.join(skillsDir, "SKILL.md"), skillContent);
+      } catch {
+        await import_promises2.default.writeFile(import_path.default.join(skillsDir, "SKILL.md"), `---
+name: make-laten
+description: Token optimization toolkit
+---
 
-// src/adapter/installer.ts
+# make-laten Skill
+
+Use make-laten CLI commands for all file/code/git operations.
+`);
+      }
+    },
+    uninstall: async () => {
+      try {
+        await import_promises2.default.rm(import_path.default.join(getHome(), ".config", "opencode", "skills", "make-laten"), { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+];
 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);
+        const detected = await agent.detected();
+        if (detected) {
+          await agent.install();
           installed.push(agent.name);
         } else {
           skipped.push(agent.name);
@@ -1203,36 +1253,27 @@ var Installer = class {
     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);
-        }
+        await agent.uninstall();
+        removed.push(agent.name);
       } catch {
       }
     }
     return { removed };
   }
   async status() {
-    const agents = await this.detector.detectAgents();
+    const result = [];
     for (const agent of agents) {
-      const adapter = this.createAdapter(agent);
-      if (adapter.isInstalled) {
-        agent.detected = await adapter.isInstalled(agent.path);
+      try {
+        const detected = await agent.detected();
+        result.push({ name: agent.name, detected, installed: false });
+      } catch {
+        result.push({ name: agent.name, detected: false, installed: false });
       }
     }
-    return agents;
-  }
-  createAdapter(agent) {
-    const config = AGENT_CONFIGS[agent.name];
-    if (config?.type === "rules") {
-      return new RulesAdapter(agent.name);
-    }
-    return new HookAdapter(agent.name);
+    return result;
   }
 };
 
@@ -1240,20 +1281,17 @@ var Installer = class {
 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}` : ""}`);
+    console.log("Detecting platforms...\n");
+    const status = await installer.status();
+    for (const s of status) {
+      const icon = s.detected ? "\u2713" : "\u25CB";
+      const label = s.detected ? "detected" : "not found";
+      console.log(`  ${icon} ${s.name} (${label})`);
     }
     return;
   }
   if (options.uninstall) {
-    console.log("Uninstalling make-laten adapters...\n");
+    console.log("Uninstalling make-laten from all platforms...\n");
     const { removed } = await installer.uninstall();
     if (removed.length === 0) {
       console.log("Nothing to uninstall.");
@@ -1262,31 +1300,262 @@ async function installCommand(options) {
     for (const name of removed) {
       console.log(`  \u2713 removed from ${name}`);
     }
+    console.log(`
+Done! Removed from ${removed.length} platform(s).`);
     return;
   }
-  console.log("Installing make-laten adapters...\n");
+  console.log("Installing make-laten across all platforms...\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`);
+    console.log(`  \u2713 ${name}`);
   }
   for (const name of skipped) {
-    console.log(`  \u25CB ${name} skipped (already configured or unavailable)`);
+    console.log(`  \u25CB ${name} (not detected)`);
   }
   console.log(`
-Done! Configured for ${installed.length} agent(s).`);
+Done! Configured for ${installed.length} platform(s).`);
+  console.log("\nAvailable commands (terminal):");
+  console.log("  mread <file>      compressed file read");
+  console.log("  mgrep <pattern>   grouped grep results");
+  console.log("  mdiff             compressed git diff");
+  console.log("  mstatus           git status summary");
+  console.log("  msearch <query>   web search");
+  console.log("  mfetch <url>      web fetch + compress");
+}
+
+// src/cli/commands/init.ts
+var import_child_process4 = require("child_process");
+var import_util4 = require("util");
+var import_promises3 = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("path"));
+var import_readline = __toESM(require("readline"));
+var execAsync4 = (0, import_util4.promisify)(import_child_process4.exec);
+function getHome2() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+async function commandExists2(cmd) {
+  try {
+    await execAsync4(`which ${cmd}`, { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function directoryExists(dirPath) {
+  try {
+    await import_promises3.default.access(dirPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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
+  });
+  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"] }
+      }
+    }
+  });
+  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"] }
+      }
+    }
+  });
+  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"] }
+      }
+    }
+  });
+  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"] }
+      }
+    }
+  });
+  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"] }
+      }
+    }
+  });
+  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),
+    configPath: import_path2.default.join(home, ".gemini", "settings.json"),
+    mcpConfig: {
+      mcpServers: {
+        "make-laten": { command: "npx", args: ["-y", "make-laten-mcp", "server"] }
+      }
+    }
+  });
+  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));
+}
+async function initCommand(options) {
+  console.log("");
+  console.log("  make-laten setup wizard");
+  console.log("  ======================");
+  console.log("");
+  const agents2 = await detectAllAgents();
+  const detected = agents2.filter((a) => a.detected);
+  const notDetected = agents2.filter((a) => !a.detected);
+  console.log("  Detected agents:");
+  for (const agent of detected) {
+    const ver = agent.version ? ` v${agent.version}` : "";
+    console.log(`    \u2713 ${agent.name}${ver}`);
+  }
+  if (notDetected.length > 0) {
+    console.log("");
+    console.log("  Not detected (skipped):");
+    for (const agent of notDetected) {
+      console.log(`    \u25CB ${agent.name}`);
+    }
+  }
+  console.log("");
+  if (options.all) {
+    for (const agent of detected) {
+      const success = await writeMCPConfig(agent);
+      if (success) {
+        console.log(`    \u2713 ${agent.name} \u2192 MCP configured`);
+      } else {
+        console.log(`    \u2717 ${agent.name} \u2192 failed`);
+      }
+    }
+  } 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));
+    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);
+        if (success) {
+          console.log(`      \u2713 ${agent.name} \u2192 MCP configured`);
+        } else {
+          console.log(`      \u2717 ${agent.name} \u2192 failed`);
+        }
+      } else {
+        console.log(`      \u25CB ${agent.name} \u2192 skipped`);
+      }
+    }
+    rl.close();
+  }
+  console.log("");
+  console.log("  Setup complete!");
+  console.log("");
+  console.log("  make-laten provides:");
+  console.log("    \u2022 MCP server \u2192 auto-compress for all AI agents");
+  console.log("    \u2022 CLI commands \u2192 mread, mgrep, mdiff, msearch, mfetch");
+  console.log("    \u2022 Shell aliases \u2192 auto-load in new terminals");
+  console.log("");
+  console.log("  Restart your agent to activate MCP tools.");
+  console.log("");
 }
 
 // src/cli/index.ts
 var program = new import_commander.Command();
-program.name("make-laten").description("Universal efficiency skill for AI coding agents").version("0.1.0");
+program.name("make-laten").description("Universal efficiency toolkit for AI coding agents").version("1.0.3");
 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");
@@ -1297,6 +1566,7 @@ cacheCmd.command("stats").description("Show cache statistics").action(cacheStats
 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.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.parse();
 //# sourceMappingURL=index.js.map