make-laten 1.0.3 → 1.1.1

package/README.md

@@ -1,49 +1,161 @@
 # make-laten
 
-Universal efficiency toolkit for AI coding agents — compress, cache, route, and optimize token usage.
+[![npm version](https://img.shields.io/npm/v/make-laten.svg)](https://www.npmjs.com/package/make-laten)
+[![license](https://img.shields.io/npm/l/make-laten.svg)](https://github.com/sukirman1901/make-laten/blob/main/LICENSE)
+[![tests](https://img.shields.io/badge/tests-201%20passing-brightgreen)]()
+
+Universal efficiency toolkit for AI coding agents — compress, cache, and optimize token usage across all platforms.
 
 ## What it does
 
 make-laten reduces token consumption when working with AI coding agents by compressing outputs, caching results, and routing operations intelligently.
 
-**Token savings:** 60-90% reduction across file reads, grep, git diff, and web fetches.
+```
+User → AI Agent → make-laten intercept → compress (60-90% savings) → return
+```
+
+**Token savings per command:**
+
+| Command | Savings | Description |
+|---------|---------|-------------|
+| `read` | **89%** | Compressed file read — exports, classes, functions only |
+| `grep` | **70%** | Grouped by file with line numbers |
+| `git diff` | **60%** | Condensed hunks, only changes shown |
+| `git status` | **65%** | Status summary |
+| `fetch` | **75%** | Web content with semantic extraction |
+
+## Quick Start
+
+**One command to set up everything:**
+
+```bash
+npx make-laten init --all
+```
 
-## Install
+This auto-detects your installed AI agents and configures MCP for each one.
+
+**Or install globally first:**
 
 ```bash
 npm install -g make-laten
+make-laten init --all
 ```
 
-## CLI Commands
+## Setup Options
+
+### Option 1: Init Wizard (Recommended)
 
 ```bash
-# Compressed file read (89% savings)
-make-laten read src/index.ts
+# Auto-configure all detected agents
+npx make-laten init --all
+
+# Per-project only (creates .mcp.json)
+npx make-laten init --project
+
+# Interactive (choose agents one by one)
+npx make-laten init
+```
+
+### Option 2: Global Install
+
+```bash
+npm install -g make-laten
+
+# Install shell aliases
+make-laten install
+
+# Or configure MCP for agents
+make-laten init --all
+```
+
+### Option 3: Shell Aliases Only
+
+```bash
+# Add to ~/.zshrc or ~/.bashrc
+source $(npm root -g)/make-laten/shell/init.sh
+```
+
+This gives you short aliases:
+
+| Alias | Command | Description |
+|-------|---------|-------------|
+| `mread` | `make-laten read` | Compressed file read |
+| `mgrep` | `make-laten grep` | Grouped grep |
+| `mdiff` | `make-laten git diff` | Compressed git diff |
+| `mstatus` | `make-laten git status` | Git status summary |
+| `msearch` | `make-laten search` | Web search |
+| `mfetch` | `make-laten fetch` | Web fetch + compress |
+
+## CLI Commands
 
-# Compressed grep with file grouping
-make-laten grep "TODO" src/
+```bash
+# File operations
+make-laten read src/index.ts         # 89% savings
+make-laten grep "TODO" src/          # grouped by file
+make-laten grep "export" . --ignore ts
 
-# Compressed git diff
-make-laten git diff
+# Git operations
+make-laten git diff                  # 60% savings
 make-laten git diff --staged
 make-laten git status
 
-# Web search (via DuckDuckGo)
+# Web operations
 make-laten search "typescript generics"
-
-# Web fetch + semantic extraction + compression
 make-laten fetch https://docs.example.com
 
-# Cache management
+# Cache
 make-laten cache stats
 make-laten cache clear
 
-# Install adapters for detected agents
-make-laten install
-make-laten install --status
-make-laten install --uninstall
+# Setup
+make-laten init --all               # detect + configure MCP
+make-laten install                   # install shell aliases
+make-laten install --status          # show what's installed
+```
+
+## MCP Server
+
+make-laten includes an MCP server that auto-compresses tool outputs for any MCP-compatible agent.
+
+**Tools provided:**
+
+| Tool | Description |
+|------|-------------|
+| `make-laten-read` | Compressed file read |
+| `make-laten-grep` | Grouped grep results |
+| `make-laten-git-diff` | Compressed git diff |
+| `make-laten-git-status` | Git status summary |
+| `make-laten-cache-stats` | Cache performance |
+
+**Manual MCP config (if needed):**
+
+```json
+{
+  "mcpServers": {
+    "make-laten": {
+      "command": "npx",
+      "args": ["-y", "make-laten-mcp", "server"]
+    }
+  }
+}
 ```
 
+## Supported Agents
+
+make-laten works with **9+ AI coding agents**:
+
+| Agent | Integration | Setup |
+|-------|-------------|-------|
+| **Claude Code** | MCP + Hooks | `npx make-laten init --all` |
+| **Cursor** | MCP + Rules | `npx make-laten init --all` |
+| **Codex** | MCP + AGENTS.md | `npx make-laten init --all` |
+| **OpenCode** | MCP + Skill | `npx make-laten init --all` |
+| **Gemini CLI** | MCP | `npx make-laten init --all` |
+| **Windsurf** | MCP | `npx make-laten init --all` |
+| **Cline** | MCP | `npx make-laten init --all` |
+| **GitHub Copilot** | MCP | `npx make-laten init --all` |
+| **Any MCP client** | MCP | Add server config manually |
+
 ## Programmatic Usage
 
 ```typescript
@@ -51,10 +163,10 @@ import {
   FileReadCompressor,
   GrepCompressor,
   GitDiffCompressor,
-  SemanticCache,
   WebRouter,
-  getAdapter,
-  createInstaller
+  RateLimiter,
+  Logger,
+  Pipeline
 } from 'make-laten'
 
 // Compress file reads
@@ -64,20 +176,59 @@ const result = await compressor.compress({
   filePath: 'src/main.ts',
   language: 'typescript'
 })
+// result.content → compressed output (89% smaller)
+// result.metadata.savings → 0.89
 
-// Semantic web search
+// Semantic web search + fetch
 const web = new WebRouter()
 const results = await web.search('how to use async await')
 const page = await web.fetch('https://example.com/docs')
+// page.content → compressed (75% smaller)
+// page.semantic → sections, code examples, key points
 
-// Cache with cosine similarity
-const cache = new SemanticCache()
-cache.set('key1', { content: 'docs', embedding: [0.1, 0.2], metadata: {} })
-const similar = cache.search([0.1, 0.2], 0.8)
+// Middleware pipeline
+const pipeline = new Pipeline()
+pipeline.use(async (ctx, next) => {
+  ctx.metadata.enhanced = true
+  return next(ctx)
+})
+
+// Rate limiting
+const limiter = new RateLimiter({ maxRequests: 100, windowMs: 60000 })
+if (limiter.allow('user1')) { /* proceed */ }
+
+// Structured logging
+const logger = new Logger({ level: 'info', handler: (entry) => console.log(entry) })
+logger.info('Processing', { file: 'src/main.ts' })
+```
+
+## Architecture
 
-// Agent adapters
-const installer = createInstaller()
-await installer.install()
+```
+┌──────────────────────────────────────────────────────────┐
+│                    User / AI Agent                        │
+│                                                          │
+│  "read src/index.ts"    "grep TODO"    "git diff"       │
+└─────────────────┬────────────────────┬──────────────────┘
+                  │                    │
+┌─────────────────▼────────────────────▼──────────────────┐
+│              make-laten MCP Server                       │
+│                                                         │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
+│  │  Compress │  │  Cache   │  │   Web    │              │
+│  │  Layer    │  │  L1/L2/L3│  │  Router  │              │
+│  └────┬─────┘  └────┬─────┘  └────┬─────┘              │
+│       │              │              │                    │
+│  ┌────▼──────────────▼──────────────▼─────┐             │
+│  │           Knowledge Graph               │             │
+│  │     (patterns, failures, learning)      │             │
+│  └────────────────────────────────────────┘             │
+└─────────────────────────────────────────────────────────┘
+                  │
+┌─────────────────▼───────────────────────────────────────┐
+│             Shell Aliases (terminal)                     │
+│   mread | mgrep | mdiff | mstatus | msearch | mfetch   │
+└─────────────────────────────────────────────────────────┘
 ```
 
 ## Modules
@@ -89,44 +240,40 @@ await installer.install()
 | `graph` | Knowledge graph for operation patterns |
 | `route` | Smart routing between compression strategies |
 | `tool` | Tool router with pattern matching |
-| `adapter` | Agent adapters (Claude Code, Codex, Gemini, Cursor, etc.) |
+| `adapter` | Agent adapters (9+ agents) |
 | `learn` | Pattern mining and failure learning |
 | `correct` | Auto-correction engine |
 | `web` | Web search, fetch, semantic extraction |
-| `middleware` | Middleware pipeline |
+| `middleware` | Middleware pipeline with chain execution |
 | `plugin` | Plugin system with lifecycle |
 | `security` | Rate limiter |
 | `logging` | Structured logger |
 | `error` | Error handler with suggestions |
 | `metrics` | Counters, gauges, histograms |
 | `session` | Session manager with timeout |
-
-## Supported Agents
-
-make-laten works with 7+ AI coding agents:
-
-- **Claude Code** — hook-based interception
-- **Codex** — hook-based interception
-- **Gemini CLI** — hook-based interception
-- **Cursor** — rules injection
-- **Windsurf** — rules injection
-- **Cline** — rules injection
-- **GitHub Copilot** — rules injection
-
-```bash
-# Auto-detect and configure
-make-laten install
-```
+| `mcp` | MCP server for AI agent integration |
 
 ## Development
 
 ```bash
+git clone https://github.com/sukirman1901/make-laten.git
+cd make-laten
 npm install
-npm test              # Run 201 tests
-npm run build         # Build CJS + ESM
+npm test              # 201 tests passing
+npm run build         # Build CJS + ESM + MCP
 npm run typecheck     # Type check
 ```
 
+## Contributing
+
+1. Fork the repo
+2. Create a feature branch (`git checkout -b feat/amazing`)
+3. Write tests first (`tests/`)
+4. Implement feature (`src/`)
+5. Run `npm test` — all 201 tests must pass
+6. Run `npm run typecheck` — must be clean
+7. Submit PR
+
 ## License
 
-MIT
+MIT © [Sukirman](https://github.com/sukirman1901)

package/dist/cli/index.js

@@ -1323,9 +1323,199 @@ Done! Configured for ${installed.length} platform(s).`);
   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 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 = [];
+  agents2.push({
+    name: "Claude Code",
+    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);
+    }
+  });
+  agents2.push({
+    name: "Cursor",
+    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);
+    }
+  });
+  agents2.push({
+    name: "Codex",
+    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);
+    }
+  });
+  agents2.push({
+    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);
+    }
+  });
+  agents2.push({
+    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);
+    }
+  });
+  agents2.push({
+    name: "Cline",
+    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);
+    }
+  });
+  agents2.push({
+    name: "Gemini CLI",
+    detected: await commandExists2("gemini") || await directoryExists(import_path2.default.join(home, ".gemini")),
+    configPath: import_path2.default.join(home, ".gemini", "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);
+    }
+  });
+  return agents2;
+}
+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 agent.writeConfig(agent.configPath);
+      if (success) {
+        console.log(`    \u2713 ${agent.name} \u2192 MCP configured`);
+      } else {
+        console.log(`    \u2717 ${agent.name} \u2192 failed to write config`);
+      }
+    }
+  } else if (options.project) {
+    const cwd = process.cwd();
+    const configPath = import_path2.default.join(cwd, ".mcp.json");
+    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 agent.writeConfig(agent.configPath);
+        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");
@@ -1336,6 +1526,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