curat 0.0.2

package/bin/cli.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execSync, spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const https = require("https");
+const http = require("http");
+const { getPlatformDir, getBinaryName, R2_PUBLIC_URL } = require("./platform");
+
+const platformDir = getPlatformDir();
+const extractDir = path.join(__dirname, "..", "dist", platformDir);
+
+fs.mkdirSync(extractDir, { recursive: true });
+
+function download(url) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("https") ? https : http;
+    client
+      .get(url, (res) => {
+        if (
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location
+        ) {
+          return download(res.headers.location).then(resolve, reject);
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+          res.resume();
+          return;
+        }
+        resolve(res);
+      })
+      .on("error", reject);
+  });
+}
+
+async function ensureBinaryZip(baseName) {
+  const zipPath = path.join(extractDir, `${baseName}.zip`);
+  if (fs.existsSync(zipPath)) return;
+
+  const version = require("../package.json").version;
+  const url = `${R2_PUBLIC_URL}/releases/v${version}/${platformDir}/${baseName}.zip`;
+  console.log("Binary not found locally. Downloading from R2...");
+
+  const res = await download(url);
+  const file = fs.createWriteStream(zipPath);
+  await new Promise((resolve, reject) => {
+    res.pipe(file);
+    file.on("finish", () => file.close(resolve));
+    file.on("error", (err) => {
+      fs.unlink(zipPath, () => {});
+      reject(err);
+    });
+  });
+  console.log("Download complete.");
+}
+
+function extractAndRun(baseName, launch) {
+  const binName = getBinaryName(baseName);
+  const binPath = path.join(extractDir, binName);
+  const zipPath = path.join(extractDir, `${baseName}.zip`);
+
+  if (fs.existsSync(binPath)) {
+    try {
+      fs.unlinkSync(binPath);
+    } catch (err) {
+      if (process.env.CURAT_DEBUG) {
+        console.warn(
+          `Warning: Could not delete existing binary: ${err.message}`,
+        );
+      }
+    }
+  }
+
+  if (!fs.existsSync(zipPath)) {
+    console.error(`${baseName}.zip not found at: ${zipPath}`);
+    console.error(`Current platform: ${platformDir}`);
+    process.exit(1);
+  }
+
+  const unzipCmd =
+    process.platform === "win32"
+      ? `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${extractDir}' -Force"`
+      : `unzip -qq -o "${zipPath}" -d "${extractDir}"`;
+  try {
+    execSync(unzipCmd, { stdio: "inherit" });
+  } catch (err) {
+    console.error("Extraction failed:", err.message);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(binPath)) {
+    console.error(`Extracted binary not found at: ${binPath}`);
+    console.error(
+      "This usually indicates a corrupt download. Please reinstall.",
+    );
+    process.exit(1);
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      fs.chmodSync(binPath, 0o755);
+    } catch {}
+  }
+
+  return launch(binPath);
+}
+
+const args = process.argv.slice(2);
+
+ensureBinaryZip("curat")
+  .then(() => {
+    extractAndRun("curat", (bin) => {
+      const proc = spawn(bin, args, { stdio: "inherit" });
+      proc.on("exit", (c) => process.exit(c || 0));
+      proc.on("error", (e) => {
+        console.error("CLI error:", e.message);
+        process.exit(1);
+      });
+      process.on("SIGINT", () => proc.kill("SIGINT"));
+      process.on("SIGTERM", () => proc.kill("SIGTERM"));
+    });
+  })
+  .catch((err) => {
+    console.error(`Failed to obtain curat binary: ${err.message}`);
+    console.error("Please check your network connection and try again.");
+    process.exit(1);
+  });

package/bin/platform.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execSync } = require("child_process");
+
+// Public bucket URL for binary distribution (not a secret)
+const R2_PUBLIC_URL = "https://pub-89e7bd64996d4da48e9371727aa0a14c.r2.dev";
+
+function getEffectiveArch() {
+  const platform = process.platform;
+  const nodeArch = process.arch;
+
+  if (platform === "darwin") {
+    if (nodeArch === "arm64") return "arm64";
+    try {
+      const translated = execSync("sysctl -in sysctl.proc_translated", {
+        encoding: "utf8",
+      }).trim();
+      if (translated === "1") return "arm64";
+    } catch {
+      // sysctl key not present -> assume true Intel
+    }
+    return "x64";
+  }
+
+  if (/arm/i.test(nodeArch)) return "arm64";
+
+  if (platform === "win32") {
+    const pa = process.env.PROCESSOR_ARCHITECTURE || "";
+    const paw = process.env.PROCESSOR_ARCHITEW6432 || "";
+    if (/arm/i.test(pa) || /arm/i.test(paw)) return "arm64";
+  }
+
+  return "x64";
+}
+
+const PLATFORM_MAP = {
+  "linux-x64": "linux-x64",
+  "linux-arm64": "linux-arm64",
+  "win32-x64": "windows-x64",
+  "win32-arm64": "windows-arm64",
+  "darwin-x64": "macos-x64",
+  "darwin-arm64": "macos-arm64",
+};
+
+function getPlatformDir() {
+  const key = `${process.platform}-${getEffectiveArch()}`;
+  const dir = PLATFORM_MAP[key];
+  if (!dir) {
+    console.error(`Unsupported platform: ${key}`);
+    console.error("Supported platforms:");
+    console.error("  - Linux x64 / ARM64");
+    console.error("  - Windows x64 / ARM64");
+    console.error("  - macOS x64 (Intel) / ARM64 (Apple Silicon)");
+    process.exit(1);
+  }
+  return dir;
+}
+
+function getBinaryName(base) {
+  return process.platform === "win32" ? `${base}.exe` : base;
+}
+
+module.exports = { getEffectiveArch, getPlatformDir, getBinaryName, R2_PUBLIC_URL };

package/bin/postinstall.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+"use strict";
+
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const { getPlatformDir, R2_PUBLIC_URL } = require("./platform");
+
+const version = require("../package.json").version;
+const platformDir = getPlatformDir();
+const distDir = path.join(__dirname, "..", "dist", platformDir);
+const zipPath = path.join(distDir, "curat.zip");
+
+function download(url) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("https") ? https : http;
+    client
+      .get(url, (res) => {
+        if (
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location
+        ) {
+          return download(res.headers.location).then(resolve, reject);
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+          res.resume();
+          return;
+        }
+        resolve(res);
+      })
+      .on("error", reject);
+  });
+}
+
+async function main() {
+  if (fs.existsSync(zipPath)) {
+    console.log(
+      `curat: binary already present at ${zipPath}, skipping download`,
+    );
+    return;
+  }
+
+  const url = `${R2_PUBLIC_URL}/releases/v${version}/${platformDir}/curat.zip`;
+  console.log(`curat: downloading binary for ${platformDir}...`);
+
+  try {
+    fs.mkdirSync(distDir, { recursive: true });
+    const res = await download(url);
+    const file = fs.createWriteStream(zipPath);
+
+    await new Promise((resolve, reject) => {
+      res.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", (err) => {
+        fs.unlink(zipPath, () => {});
+        reject(err);
+      });
+    });
+
+    console.log("curat: binary downloaded successfully");
+  } catch (err) {
+    console.warn(`curat: postinstall download failed: ${err.message}`);
+    console.warn("curat: binary will be downloaded on first run");
+    try {
+      fs.unlinkSync(zipPath);
+    } catch {}
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "curat",
+  "private": false,
+  "version": "0.0.2",
+  "description": "Curate codebases into AI-friendly context files",
+  "bin": {
+    "curat": "bin/cli.js"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "context",
+    "codebase",
+    "curate",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "scripts": {
+    "postinstall": "node bin/postinstall.js"
+  },
+  "dependencies": {},
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}