make-laten 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -996,22 +996,361 @@ var RulesAdapter = class {
   }
 };
 
-// src/adapter/detector.ts
-import { exec } from "child_process";
-import { promisify } from "util";
+// src/adapter/installer.ts
 import fs3 from "fs/promises";
 import path3 from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
 var execAsync = promisify(exec);
+var RULES_CONTENT = `
+# make-laten efficiency rules
+
+## 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
+
+## 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 execAsync(`which ${cmd}`, { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var agents = [
+  {
+    name: "terminal (shell aliases)",
+    detected: async () => true,
+    install: async () => {
+      const shellInit = await execAsync("echo $SHELL").then((r) => r.stdout.trim());
+      const rcFile = shellInit.includes("zsh") ? ".zshrc" : ".bashrc";
+      const rcPath = path3.join(getHome(), rcFile);
+      const marker = "make-laten shell";
+      let existing = "";
+      try {
+        existing = await fs3.readFile(rcPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes(marker)) {
+        const npmRoot = await execAsync("npm root -g").then((r) => r.stdout.trim());
+        const initScript = `
+# make-laten shell integration
+source ${npmRoot}/make-laten/shell/init.sh
+`;
+        await fs3.appendFile(rcPath, initScript);
+      }
+    },
+    uninstall: async () => {
+      const shellInit = await execAsync("echo $SHELL").then((r) => r.stdout.trim());
+      const rcFile = shellInit.includes("zsh") ? ".zshrc" : ".bashrc";
+      const rcPath = path3.join(getHome(), rcFile);
+      try {
+        let content = await fs3.readFile(rcPath, "utf-8");
+        content = content.replace(/\n# make-laten shell integration\nsource .*\/make-laten\/shell\/init\.sh\n/g, "");
+        await fs3.writeFile(rcPath, content);
+      } catch {
+      }
+    }
+  },
+  {
+    name: "claude-code",
+    detected: async () => commandExists("claude"),
+    install: async () => {
+      const hooksDir = path3.join(getHome(), ".claude", "hooks");
+      await fs3.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 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(path3.join(hooksDir, "pre-tool-use.js"), preHook);
+      await fs3.writeFile(path3.join(hooksDir, "post-tool-use.js"), postHook);
+    },
+    uninstall: async () => {
+      const hooksDir = path3.join(getHome(), ".claude", "hooks");
+      try {
+        await fs3.rm(path3.join(hooksDir, "pre-tool-use.js"), { force: true });
+      } catch {
+      }
+      try {
+        await fs3.rm(path3.join(hooksDir, "post-tool-use.js"), { force: true });
+      } catch {
+      }
+    }
+  },
+  {
+    name: "cursor",
+    detected: async () => {
+      try {
+        await fs3.access(path3.join(getHome(), ".cursor"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const rulesDir = path3.join(getHome(), ".cursor", "rules");
+      await fs3.mkdir(rulesDir, { recursive: true });
+      const ruleFile = path3.join(rulesDir, "make-laten.mdc");
+      const content = `---
+description: make-laten efficiency rules
+globs:
+---
+${RULES_CONTENT}`;
+      await fs3.writeFile(ruleFile, content);
+    },
+    uninstall: async () => {
+      try {
+        await fs3.rm(path3.join(getHome(), ".cursor", "rules", "make-laten.mdc"), { force: true });
+      } catch {
+      }
+    }
+  },
+  {
+    name: "codex",
+    detected: async () => commandExists("codex"),
+    install: async () => {
+      const agentsMd = path3.join(process.cwd(), "AGENTS.md");
+      let existing = "";
+      try {
+        existing = await fs3.readFile(agentsMd, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        const content = existing + "\n\n## make-laten Integration\n" + RULES_CONTENT;
+        await fs3.writeFile(agentsMd, content);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await fs3.readFile(path3.join(process.cwd(), "AGENTS.md"), "utf-8");
+        content = content.replace(/\n## make-laten Integration[\s\S]*$/, "");
+        await fs3.writeFile(path3.join(process.cwd(), "AGENTS.md"), content.trim() + "\n");
+      } catch {
+      }
+    }
+  },
+  {
+    name: "windsurf",
+    detected: async () => {
+      try {
+        await fs3.access(path3.join(process.cwd(), ".windsurf"));
+        return true;
+      } catch {
+        try {
+          await fs3.access(path3.join(getHome(), ".windsurf"));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    },
+    install: async () => {
+      const rulesPath = path3.join(process.cwd(), ".windsurfrules");
+      let existing = "";
+      try {
+        existing = await fs3.readFile(rulesPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await fs3.writeFile(rulesPath, existing + "\n\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await fs3.readFile(path3.join(process.cwd(), ".windsurfrules"), "utf-8");
+        content = content.replace(/\n# make-laten efficiency rules[\s\S]*$/, "");
+        await fs3.writeFile(path3.join(process.cwd(), ".windsurfrules"), content.trim() + "\n");
+      } catch {
+      }
+    }
+  },
+  {
+    name: "cline",
+    detected: async () => {
+      try {
+        await fs3.access(path3.join(process.cwd(), ".clinerules"));
+        return true;
+      } catch {
+        try {
+          await fs3.access(path3.join(getHome(), ".cline"));
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    },
+    install: async () => {
+      const rulesPath = path3.join(process.cwd(), ".clinerules");
+      let existing = "";
+      try {
+        existing = await fs3.readFile(rulesPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await fs3.writeFile(rulesPath, existing + "\n\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await fs3.readFile(path3.join(process.cwd(), ".clinerules"), "utf-8");
+        content = content.replace(/\n# make-laten efficiency rules[\s\S]*$/, "");
+        await fs3.writeFile(path3.join(process.cwd(), ".clinerules"), content.trim() + "\n");
+      } catch {
+      }
+    }
+  },
+  {
+    name: "copilot",
+    detected: async () => {
+      try {
+        await fs3.access(path3.join(process.cwd(), ".github"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const dir = path3.join(process.cwd(), ".github");
+      await fs3.mkdir(dir, { recursive: true });
+      const instructionsPath = path3.join(dir, "copilot-instructions.md");
+      let existing = "";
+      try {
+        existing = await fs3.readFile(instructionsPath, "utf-8");
+      } catch {
+      }
+      if (!existing.includes("make-laten")) {
+        await fs3.writeFile(instructionsPath, existing + "\n\n## make-laten Efficiency\n" + RULES_CONTENT);
+      }
+    },
+    uninstall: async () => {
+      try {
+        let content = await fs3.readFile(path3.join(process.cwd(), ".github", "copilot-instructions.md"), "utf-8");
+        content = content.replace(/\n## make-laten Efficiency[\s\S]*$/, "");
+        await fs3.writeFile(path3.join(process.cwd(), ".github", "copilot-instructions.md"), content.trim() + "\n");
+      } catch {
+      }
+    }
+  },
+  {
+    name: "opencode",
+    detected: async () => {
+      try {
+        await fs3.access(path3.join(getHome(), ".config", "opencode"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    install: async () => {
+      const skillsDir = path3.join(getHome(), ".config", "opencode", "skills", "make-laten");
+      await fs3.mkdir(skillsDir, { recursive: true });
+      const npmRoot = await execAsync("npm root -g").then((r) => r.stdout.trim());
+      const skillSrc = path3.join(npmRoot, "make-laten", "skills", "SKILL.md");
+      try {
+        const skillContent = await fs3.readFile(skillSrc, "utf-8");
+        await fs3.writeFile(path3.join(skillsDir, "SKILL.md"), skillContent);
+      } catch {
+        await fs3.writeFile(path3.join(skillsDir, "SKILL.md"), `---
+name: make-laten
+description: Token optimization toolkit
+---
+
+# make-laten Skill
+
+Use make-laten CLI commands for all file/code/git operations.
+`);
+      }
+    },
+    uninstall: async () => {
+      try {
+        await fs3.rm(path3.join(getHome(), ".config", "opencode", "skills", "make-laten"), { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+];
+var Installer = class {
+  async install() {
+    const installed = [];
+    const skipped = [];
+    for (const agent of agents) {
+      try {
+        const detected = await agent.detected();
+        if (detected) {
+          await agent.install();
+          installed.push(agent.name);
+        } else {
+          skipped.push(agent.name);
+        }
+      } catch {
+        skipped.push(agent.name);
+      }
+    }
+    return { installed, skipped };
+  }
+  async uninstall() {
+    const removed = [];
+    for (const agent of agents) {
+      try {
+        await agent.uninstall();
+        removed.push(agent.name);
+      } catch {
+      }
+    }
+    return { removed };
+  }
+  async status() {
+    const result = [];
+    for (const agent of agents) {
+      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 result;
+  }
+};
+
+// src/adapter/detector.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import fs4 from "fs/promises";
+import path4 from "path";
+var execAsync2 = promisify2(exec2);
 var AgentDetector = class {
   async detectAgents() {
-    const agents = [];
+    const agents2 = [];
     for (const [name, config] of Object.entries(AGENT_CONFIGS)) {
       const detected = await this.detectAgent(name, config.type);
       if (detected) {
-        agents.push(detected);
+        agents2.push(detected);
       }
     }
-    return agents;
+    return agents2;
   }
   async detectAgent(name, type) {
     const commands = {
@@ -1021,7 +1360,7 @@ var AgentDetector = class {
     };
     if (commands[name]) {
       try {
-        const { stdout } = await execAsync(commands[name], { timeout: 5e3 });
+        const { stdout } = await execAsync2(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 };
@@ -1033,7 +1372,7 @@ var AgentDetector = class {
       const rulesPath = AGENT_CONFIGS[name]?.rulesFile;
       if (rulesPath) {
         try {
-          await fs3.access(path3.join(process.cwd(), rulesPath));
+          await fs4.access(path4.join(process.cwd(), rulesPath));
           return { name, type, path: process.cwd(), version: null, detected: true };
         } catch {
           return null;
@@ -1045,15 +1384,15 @@ var AgentDetector = class {
   async getAgentPath(name) {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     const paths = {
-      "claude-code": path3.join(home, ".claude"),
-      "codex": path3.join(home, ".codex"),
-      "gemini-cli": path3.join(home, ".gemini")
+      "claude-code": path4.join(home, ".claude"),
+      "codex": path4.join(home, ".codex"),
+      "gemini-cli": path4.join(home, ".gemini")
     };
-    return paths[name] || path3.join(home, `.${name}`);
+    return paths[name] || path4.join(home, `.${name}`);
   }
   async hasCommand(cmd) {
     try {
-      await execAsync(`which ${cmd}`, { timeout: 3e3 });
+      await execAsync2(`which ${cmd}`, { timeout: 3e3 });
       return true;
     } catch {
       return false;
@@ -1061,62 +1400,6 @@ var AgentDetector = class {
   }
 };
 
-// src/adapter/installer.ts
-var Installer = class {
-  detector = new AgentDetector();
-  async install() {
-    const agents = await this.detector.detectAgents();
-    const installed = [];
-    const skipped = [];
-    for (const agent of agents) {
-      try {
-        const adapter = this.createAdapter(agent);
-        if (adapter.install) {
-          await adapter.install(agent.path);
-          installed.push(agent.name);
-        } else {
-          skipped.push(agent.name);
-        }
-      } catch {
-        skipped.push(agent.name);
-      }
-    }
-    return { installed, skipped };
-  }
-  async uninstall() {
-    const agents = await this.detector.detectAgents();
-    const removed = [];
-    for (const agent of agents) {
-      try {
-        const adapter = this.createAdapter(agent);
-        if (adapter.uninstall) {
-          await adapter.uninstall(agent.path);
-          removed.push(agent.name);
-        }
-      } catch {
-      }
-    }
-    return { removed };
-  }
-  async status() {
-    const agents = await this.detector.detectAgents();
-    for (const agent of agents) {
-      const adapter = this.createAdapter(agent);
-      if (adapter.isInstalled) {
-        agent.detected = await adapter.isInstalled(agent.path);
-      }
-    }
-    return agents;
-  }
-  createAdapter(agent) {
-    const config = AGENT_CONFIGS[agent.name];
-    if (config?.type === "rules") {
-      return new RulesAdapter(agent.name);
-    }
-    return new HookAdapter(agent.name);
-  }
-};
-
 // src/adapter/index.ts
 var adapters = /* @__PURE__ */ new Map();
 adapters.set("claude-code", new ClaudeCodeAdapter());