make-laten 1.0.1 → 1.0.3

package/dist/cli/index.mjs

@@ -915,260 +915,310 @@ async function fetchCommand(url, options) {
   }
 }
 
-// src/adapter/detector.ts
-import { exec as exec3 } from "child_process";
-import { promisify as promisify3 } from "util";
+// src/adapter/installer.ts
 import fs2 from "fs/promises";
 import path from "path";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
+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 = 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;
+## 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 = path.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 fs2.readFile(rcPath, "utf-8");
       } 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;
-        }
+      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 fs2.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 = path.join(getHome(), rcFile);
+      try {
+        let content = await fs2.readFile(rcPath, "utf-8");
+        content = content.replace(/\n# make-laten shell integration\nsource .*\/make-laten\/shell\/init\.sh\n/g, "");
+        await fs2.writeFile(rcPath, content);
+      } catch {
       }
     }
-    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
+  },
+  {
+    name: "claude-code",
+    detected: async () => commandExists("claude"),
+    install: async () => {
+      const hooksDir = path.join(getHome(), ".claude", "hooks");
+      await fs2.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 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 {
+process.stdout.write(JSON.stringify(input));`;
+      await fs2.writeFile(path.join(hooksDir, "pre-tool-use.js"), preHook);
+      await fs2.writeFile(path.join(hooksDir, "post-tool-use.js"), postHook);
+    },
+    uninstall: async () => {
+      const hooksDir = path.join(getHome(), ".claude", "hooks");
+      try {
+        await fs2.rm(path.join(hooksDir, "pre-tool-use.js"), { force: true });
+      } catch {
+      }
+      try {
+        await fs2.rm(path.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;
+  },
+  {
+    name: "cursor",
+    detected: async () => {
+      try {
+        await fs2.access(path.join(getHome(), ".cursor"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const rulesDir = path.join(getHome(), ".cursor", "rules");
+      await fs2.mkdir(rulesDir, { recursive: true });
+      const ruleFile = path.join(rulesDir, "make-laten.mdc");
+      const content = `---
+description: make-laten efficiency rules
+globs:
+---
+${RULES_CONTENT}`;
+      await fs2.writeFile(ruleFile, content);
+    },
+    uninstall: async () => {
+      try {
+        await fs2.rm(path.join(getHome(), ".cursor", "rules", "make-laten.mdc"), { force: true });
+      } catch {
+      }
     }
-  }
-};
-
-// 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}`);
+  },
+  {
+    name: "codex",
+    detected: async () => commandExists("codex"),
+    install: async () => {
+      const agentsMd = path.join(process.cwd(), "AGENTS.md");
+      let existing = "";
+      try {
+        existing = await fs2.readFile(agentsMd, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        const content = existing + "\n\n## make-laten Integration\n" + RULES_CONTENT;
+        await fs2.writeFile(agentsMd, content);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await fs2.readFile(path.join(process.cwd(), "AGENTS.md"), "utf-8");
+        content = content.replace(/\n## make-laten Integration[\s\S]*$/, "");
+        await fs2.writeFile(path.join(process.cwd(), "AGENTS.md"), content.trim() + "\n");
+      } catch {
+      }
     }
-    const rulesPath = path3.join(agentPath, config.rulesFile);
-    const existing = await fs4.readFile(rulesPath, "utf-8").catch(() => "");
-    if (existing.includes("make-laten")) {
-      return;
+  },
+  {
+    name: "windsurf",
+    detected: async () => {
+      try {
+        await fs2.access(path.join(process.cwd(), ".windsurf"));
+        return true;
+      } catch {
+        try {
+          await fs2.access(path.join(getHome(), ".windsurf"));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    },
+    install: async () => {
+      const rulesPath = path.join(process.cwd(), ".windsurfrules");
+      let existing = "";
+      try {
+        existing = await fs2.readFile(rulesPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await fs2.writeFile(rulesPath, existing + "\n\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await fs2.readFile(path.join(process.cwd(), ".windsurfrules"), "utf-8");
+        content = content.replace(/\n# make-laten efficiency rules[\s\S]*$/, "");
+        await fs2.writeFile(path.join(process.cwd(), ".windsurfrules"), content.trim() + "\n");
+      } catch {
+      }
     }
-    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");
+  },
+  {
+    name: "cline",
+    detected: async () => {
+      try {
+        await fs2.access(path.join(process.cwd(), ".clinerules"));
+        return true;
+      } catch {
+        try {
+          await fs2.access(path.join(getHome(), ".cline"));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    },
+    install: async () => {
+      const rulesPath = path.join(process.cwd(), ".clinerules");
+      let existing = "";
+      try {
+        existing = await fs2.readFile(rulesPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await fs2.writeFile(rulesPath, existing + "\n\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await fs2.readFile(path.join(process.cwd(), ".clinerules"), "utf-8");
+        content = content.replace(/\n# make-laten efficiency rules[\s\S]*$/, "");
+        await fs2.writeFile(path.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 fs4.readFile(path3.join(agentPath, config.rulesFile), "utf-8");
-      return content.includes("make-laten");
-    } catch {
-      return false;
+  },
+  {
+    name: "copilot",
+    detected: async () => {
+      try {
+        await fs2.access(path.join(process.cwd(), ".github"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const dir = path.join(process.cwd(), ".github");
+      await fs2.mkdir(dir, { recursive: true });
+      const instructionsPath = path.join(dir, "copilot-instructions.md");
+      let existing = "";
+      try {
+        existing = await fs2.readFile(instructionsPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await fs2.writeFile(instructionsPath, existing + "\n\n## make-laten Efficiency\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await fs2.readFile(path.join(process.cwd(), ".github", "copilot-instructions.md"), "utf-8");
+        content = content.replace(/\n## make-laten Efficiency[\s\S]*$/, "");
+        await fs2.writeFile(path.join(process.cwd(), ".github", "copilot-instructions.md"), content.trim() + "\n");
+      } catch {
+      }
     }
-  }
-};
+  },
+  {
+    name: "opencode",
+    detected: async () => {
+      try {
+        await fs2.access(path.join(getHome(), ".config", "opencode"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const skillsDir = path.join(getHome(), ".config", "opencode", "skills", "make-laten");
+      await fs2.mkdir(skillsDir, { recursive: true });
+      const npmRoot = await execAsync3("npm root -g").then((r) => r.stdout.trim());
+      const skillSrc = path.join(npmRoot, "make-laten", "skills", "SKILL.md");
+      try {
+        const skillContent = await fs2.readFile(skillSrc, "utf-8");
+        await fs2.writeFile(path.join(skillsDir, "SKILL.md"), skillContent);
+      } catch {
+        await fs2.writeFile(path.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 fs2.rm(path.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);
@@ -1180,36 +1230,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;
   }
 };
 
@@ -1217,20 +1258,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.");
@@ -1239,26 +1277,27 @@ 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/index.ts