lean-ctx-bin 2.5.0

package/README.md

@@ -0,0 +1,47 @@
+# lean-ctx-bin
+
+Pre-built binary distribution of [lean-ctx](https://github.com/yvgude/lean-ctx) — the Cognitive Filter for AI Engineering.
+
+No Rust toolchain required. The correct binary for your platform is downloaded automatically during `npm install`.
+
+## Install
+
+```bash
+npm install -g lean-ctx-bin
+```
+
+After installing, run the one-command setup:
+
+```bash
+lean-ctx setup
+```
+
+This auto-detects your shell and editors, installs shell aliases, creates MCP configs, and verifies everything.
+
+## Supported Platforms
+
+| Platform | Architecture |
+|----------|-------------|
+| Linux | x86_64, aarch64 |
+| macOS | x86_64, Apple Silicon |
+| Windows | x86_64 |
+
+## Alternative Install Methods
+
+```bash
+# Universal installer (no Rust needed)
+curl -fsSL https://leanctx.com/install.sh | sh
+
+# Homebrew (macOS/Linux)
+brew tap yvgude/lean-ctx && brew install lean-ctx
+
+# Cargo (requires Rust)
+cargo install lean-ctx
+```
+
+## Links
+
+- [Documentation](https://leanctx.com/docs/getting-started)
+- [GitHub](https://github.com/yvgude/lean-ctx)
+- [crates.io](https://crates.io/crates/lean-ctx)
+- [Discord](https://discord.gg/pTHkG9Hew9)

package/bin/lean-ctx.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+const IS_WIN = process.platform === "win32";
+const BINARY = path.join(__dirname, IS_WIN ? "lean-ctx.exe" : "lean-ctx");
+
+const result = spawnSync(BINARY, process.argv.slice(2), {
+  stdio: "inherit",
+  env: process.env,
+});
+
+if (result.error) {
+  if (result.error.code === "ENOENT") {
+    console.error("lean-ctx binary not found. Run: npm rebuild lean-ctx-bin");
+  } else {
+    console.error(`lean-ctx: ${result.error.message}`);
+  }
+  process.exit(127);
+}
+
+process.exit(result.status ?? 1);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "lean-ctx-bin",
+  "version": "2.5.0",
+  "description": "lean-ctx — the token-efficient context tool for LLM coding agents. Installs a pre-built binary, no Rust required.",
+  "keywords": ["lean-ctx", "mcp", "llm", "context", "claude", "cursor", "ai", "token-optimization"],
+  "homepage": "https://leanctx.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yvgude/lean-ctx.git",
+    "directory": "packages/lean-ctx-bin"
+  },
+  "license": "MIT",
+  "bin": {
+    "lean-ctx": "./bin/lean-ctx.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "files": [
+    "bin/",
+    "postinstall.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=16"
+  }
+}

package/postinstall.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const { createGunzip } = require("zlib");
+
+const REPO = "yvgude/lean-ctx";
+const BIN_DIR = path.join(__dirname, "bin");
+const IS_WIN = process.platform === "win32";
+const BINARY_NAME = IS_WIN ? "lean-ctx.exe" : "lean-ctx";
+const BINARY_PATH = path.join(BIN_DIR, BINARY_NAME);
+
+function getTarget() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const key = `${platform}-${arch}`;
+  const targets = {
+    "linux-x64": "x86_64-unknown-linux-gnu",
+    "linux-arm64": "aarch64-unknown-linux-gnu",
+    "darwin-x64": "x86_64-apple-darwin",
+    "darwin-arm64": "aarch64-apple-darwin",
+    "win32-x64": "x86_64-pc-windows-msvc",
+  };
+
+  const target = targets[key];
+  if (!target) {
+    console.error(`Unsupported platform: ${key}`);
+    console.error("Build from source instead: cargo install lean-ctx");
+    process.exit(1);
+  }
+  return target;
+}
+
+function httpsGet(url) {
+  return new Promise((resolve, reject) => {
+    const get = (u) => {
+      https.get(u, { headers: { "User-Agent": "lean-ctx-bin-npm" } }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          get(res.headers.location);
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode} for ${u}`));
+          return;
+        }
+        resolve(res);
+      }).on("error", reject);
+    };
+    get(url);
+  });
+}
+
+function httpsGetJson(url) {
+  return new Promise((resolve, reject) => {
+    httpsGet(url).then((res) => {
+      let data = "";
+      res.on("data", (c) => (data += c));
+      res.on("end", () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(e); }
+      });
+    }).catch(reject);
+  });
+}
+
+async function downloadToFile(url, dest) {
+  const res = await httpsGet(url);
+  return new Promise((resolve, reject) => {
+    const ws = fs.createWriteStream(dest);
+    res.pipe(ws);
+    ws.on("finish", resolve);
+    ws.on("error", reject);
+  });
+}
+
+function extractTarGz(archive, destDir, binaryName) {
+  const gunzip = createGunzip();
+  const input = fs.createReadStream(archive);
+
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    input.pipe(gunzip)
+      .on("data", (c) => chunks.push(c))
+      .on("end", () => {
+        const buf = Buffer.concat(chunks);
+        let offset = 0;
+        while (offset < buf.length) {
+          const header = buf.subarray(offset, offset + 512);
+          if (header.every((b) => b === 0)) break;
+
+          const name = header.subarray(0, 100).toString("utf8").replace(/\0/g, "");
+          const sizeStr = header.subarray(124, 136).toString("utf8").replace(/\0/g, "").trim();
+          const size = parseInt(sizeStr, 8) || 0;
+          offset += 512;
+
+          const baseName = path.basename(name);
+          if (baseName === binaryName && size > 0) {
+            const dest = path.join(destDir, binaryName);
+            fs.writeFileSync(dest, buf.subarray(offset, offset + size));
+            if (!IS_WIN) fs.chmodSync(dest, 0o755);
+            resolve(dest);
+            return;
+          }
+          offset += Math.ceil(size / 512) * 512;
+        }
+        reject(new Error(`${binaryName} not found in archive`));
+      })
+      .on("error", reject);
+  });
+}
+
+async function main() {
+  if (fs.existsSync(BINARY_PATH)) {
+    console.log("lean-ctx binary already exists, skipping download");
+    return;
+  }
+
+  const target = getTarget();
+  console.log(`lean-ctx: installing for ${target}...`);
+
+  const release = await httpsGetJson(`https://api.github.com/repos/${REPO}/releases/latest`);
+  const tag = release.tag_name;
+  console.log(`lean-ctx: latest release ${tag}`);
+
+  const ext = IS_WIN ? ".zip" : ".tar.gz";
+  const assetName = `lean-ctx-${target}${ext}`;
+  const asset = (release.assets || []).find((a) => a.name === assetName);
+  if (!asset) {
+    console.error(`No binary for ${target}. Install from source: cargo install lean-ctx`);
+    process.exit(1);
+  }
+
+  const tmpDir = fs.mkdtempSync(path.join(require("os").tmpdir(), "lean-ctx-"));
+  const archivePath = path.join(tmpDir, assetName);
+
+  try {
+    await downloadToFile(asset.browser_download_url, archivePath);
+    console.log("lean-ctx: downloaded, extracting...");
+
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+
+    if (IS_WIN) {
+      execSync(`tar -xf "${archivePath}" -C "${BIN_DIR}"`, { stdio: "ignore" });
+    } else {
+      await extractTarGz(archivePath, BIN_DIR, "lean-ctx");
+    }
+
+    console.log(`lean-ctx: installed to ${BINARY_PATH}`);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+main().catch((err) => {
+  console.error(`lean-ctx: installation failed: ${err.message}`);
+  console.error("Install from source instead: cargo install lean-ctx");
+  process.exit(1);
+});