better-coder 0.1.0

package/README.md

@@ -0,0 +1,27 @@
+# better-coder
+
+Prompt AI agents against local git repositories with zero friction.
+
+## Quick Start
+
+```bash
+npx better-coder
+```
+
+First run downloads the app (~50MB). Subsequent runs launch instantly from cache.
+
+## Supported Platforms
+
+- macOS (Apple Silicon and Intel)
+- Linux (x64 and ARM64)
+- Windows (x64 and ARM64)
+
+## Cache Location
+
+Binaries are cached at:
+- macOS/Linux: ~/.better-coder/bin/
+- Windows: %USERPROFILE%\.better-coder\bin\
+
+## Local Development
+
+Set BETTER_CODER_LOCAL=1 to use binaries from npx-cli/dist/ instead of CDN.

package/bin/cli.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require("child_process");
+const AdmZip = require("adm-zip");
+const path = require("path");
+const fs = require("fs");
+const { ensureBinary, BINARY_TAG, CACHE_DIR, LOCAL_DEV_MODE, LOCAL_DIST_DIR, R2_BASE_URL, getLatestVersion } = require("./download");
+
+const CLI_VERSION = require("../package.json").version;
+
+// Resolve effective arch for our published 64-bit binaries only.
+// Any ARM → arm64; anything else → x64. On macOS, handle Rosetta.
+function getEffectiveArch() {
+  const platform = process.platform;
+  const nodeArch = process.arch;
+
+  if (platform === "darwin") {
+    // If Node itself is arm64, we're natively on Apple silicon
+    if (nodeArch === "arm64") return "arm64";
+
+    // Otherwise check for Rosetta translation
+    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";
+  }
+
+  // Non-macOS: coerce to broad families we support
+  if (/arm/i.test(nodeArch)) return "arm64";
+
+  // On Windows with 32-bit Node (ia32), detect OS arch via env
+  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 = process.platform;
+const arch = getEffectiveArch();
+
+// Map to our build target names
+function getPlatformDir() {
+  if (platform === "linux" && arch === "x64") return "linux-x64";
+  if (platform === "linux" && arch === "arm64") return "linux-arm64";
+  if (platform === "win32" && arch === "x64") return "windows-x64";
+  if (platform === "win32" && arch === "arm64") return "windows-arm64";
+  if (platform === "darwin" && arch === "x64") return "macos-x64";
+  if (platform === "darwin" && arch === "arm64") return "macos-arm64";
+
+  console.error(`Unsupported platform: ${platform}-${arch}`);
+  console.error("Supported platforms:");
+  console.error("  - Linux x64");
+  console.error("  - Linux ARM64");
+  console.error("  - Windows x64");
+  console.error("  - Windows ARM64");
+  console.error("  - macOS x64 (Intel)");
+  console.error("  - macOS ARM64 (Apple Silicon)");
+  process.exit(1);
+}
+
+function getBinaryName(base) {
+  return platform === "win32" ? `${base}.exe` : base;
+}
+
+const platformDir = getPlatformDir();
+// In local dev mode, extract directly to dist directory; otherwise use global cache
+const versionCacheDir = LOCAL_DEV_MODE
+  ? path.join(LOCAL_DIST_DIR, platformDir)
+  : path.join(CACHE_DIR, BINARY_TAG, platformDir);
+
+function showProgress(downloaded, total) {
+  const percent = total ? Math.round((downloaded / total) * 100) : 0;
+  const mb = (downloaded / (1024 * 1024)).toFixed(1);
+  const totalMb = total ? (total / (1024 * 1024)).toFixed(1) : "?";
+  process.stderr.write(`\r   Downloading: ${mb}MB / ${totalMb}MB (${percent}%)`);
+}
+
+async function extractAndRun(baseName, launch) {
+  const binName = getBinaryName(baseName);
+  const binPath = path.join(versionCacheDir, binName);
+  const zipPath = path.join(versionCacheDir, `${baseName}.zip`);
+
+  // Clean old binary if exists
+  try {
+    if (fs.existsSync(binPath)) {
+      fs.unlinkSync(binPath);
+    }
+  } catch (err) {
+    if (process.env.BETTER_CODER_DEBUG) {
+      console.warn(`Warning: Could not delete existing binary: ${err.message}`);
+    }
+  }
+
+  // Download if not cached
+  if (!fs.existsSync(zipPath)) {
+    console.error(`Downloading ${baseName}...`);
+    try {
+      await ensureBinary(platformDir, baseName, showProgress);
+      console.error(""); // newline after progress
+    } catch (err) {
+      console.error(`\nDownload failed: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Extract
+  if (!fs.existsSync(binPath)) {
+    try {
+      const zip = new AdmZip(zipPath);
+      zip.extractAllTo(versionCacheDir, true);
+    } catch (err) {
+      console.error("Extraction failed:", err.message);
+      try {
+        fs.unlinkSync(zipPath);
+      } catch {}
+      process.exit(1);
+    }
+  }
+
+  if (!fs.existsSync(binPath)) {
+    console.error(`Extracted binary not found at: ${binPath}`);
+    console.error("This usually indicates a corrupt download. Please try again.");
+    process.exit(1);
+  }
+
+  // Set permissions (non-Windows)
+  if (platform !== "win32") {
+    try {
+      fs.chmodSync(binPath, 0o755);
+    } catch {}
+  }
+
+  return launch(binPath);
+}
+
+async function main() {
+  fs.mkdirSync(versionCacheDir, { recursive: true });
+
+  // Non-blocking update check (skip in local dev mode and when R2 URL not configured)
+  const hasValidR2Url = !R2_BASE_URL.startsWith("__");
+  if (!LOCAL_DEV_MODE && hasValidR2Url) {
+    getLatestVersion()
+      .then((latest) => {
+        if (latest && latest !== CLI_VERSION) {
+          setTimeout(() => {
+            console.log(`\nUpdate available: ${CLI_VERSION} -> ${latest}`);
+            console.log(`Run: npx better-coder@latest`);
+          }, 2000);
+        }
+      })
+      .catch(() => {});
+  }
+
+  const modeLabel = LOCAL_DEV_MODE ? " (local dev)" : "";
+  console.log(`Starting better-coder v${CLI_VERSION}${modeLabel}...`);
+
+  await extractAndRun("better-coder", (bin) => {
+    if (platform === "win32") {
+      execSync(`"${bin}"`, { stdio: "inherit" });
+    } else {
+      execSync(`"${bin}"`, { stdio: "inherit" });
+    }
+  });
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err.message);
+  if (process.env.BETTER_CODER_DEBUG) {
+    console.error(err.stack);
+  }
+  process.exit(1);
+});

package/bin/download.js

@@ -0,0 +1,137 @@
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+// Replaced during npm pack by workflow
+const R2_BASE_URL = "https://pub-705b64c8394843c58988d5d3978fac1d.r2.dev";
+const BINARY_TAG = "v0.1.0-20260122005408"; // e.g., v0.1.0-20260121120000
+const CACHE_DIR = path.join(require("os").homedir(), ".better-coder", "bin");
+
+// Local development mode: use binaries from npx-cli/dist/ instead of R2
+// Only activate if dist/ exists (i.e., running from source after local build)
+const LOCAL_DIST_DIR = path.join(__dirname, "..", "dist");
+const LOCAL_DEV_MODE = fs.existsSync(LOCAL_DIST_DIR) || process.env.BETTER_CODER_LOCAL === "1";
+
+async function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return fetchJson(res.headers.location).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+      }
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse JSON from ${url}`));
+        }
+      });
+    }).on("error", reject);
+  });
+}
+
+async function downloadFile(url, destPath, expectedSha256, onProgress) {
+  const tempPath = destPath + ".tmp";
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(tempPath);
+    const hash = crypto.createHash("sha256");
+
+    const cleanup = () => {
+      try {
+        fs.unlinkSync(tempPath);
+      } catch {}
+    };
+
+    https.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        file.close();
+        cleanup();
+        return downloadFile(res.headers.location, destPath, expectedSha256, onProgress)
+          .then(resolve)
+          .catch(reject);
+      }
+
+      if (res.statusCode !== 200) {
+        file.close();
+        cleanup();
+        return reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
+      }
+
+      const totalSize = parseInt(res.headers["content-length"], 10);
+      let downloadedSize = 0;
+
+      res.on("data", (chunk) => {
+        downloadedSize += chunk.length;
+        hash.update(chunk);
+        if (onProgress) onProgress(downloadedSize, totalSize);
+      });
+      res.pipe(file);
+
+      file.on("finish", () => {
+        file.close();
+        const actualSha256 = hash.digest("hex");
+        if (expectedSha256 && actualSha256 !== expectedSha256) {
+          cleanup();
+          reject(new Error(`Checksum mismatch: expected ${expectedSha256}, got ${actualSha256}`));
+        } else {
+          try {
+            fs.renameSync(tempPath, destPath);
+            resolve(destPath);
+          } catch (err) {
+            cleanup();
+            reject(err);
+          }
+        }
+      });
+    }).on("error", (err) => {
+      file.close();
+      cleanup();
+      reject(err);
+    });
+  });
+}
+
+async function ensureBinary(platform, binaryName, onProgress) {
+  // In local dev mode, use binaries directly from npx-cli/dist/
+  if (LOCAL_DEV_MODE) {
+    const localZipPath = path.join(LOCAL_DIST_DIR, platform, `${binaryName}.zip`);
+    if (fs.existsSync(localZipPath)) {
+      return localZipPath;
+    }
+    throw new Error(
+      `Local binary not found: ${localZipPath}\n` +
+      `Run local build script first to build the binaries.`
+    );
+  }
+
+  const cacheDir = path.join(CACHE_DIR, BINARY_TAG, platform);
+  const zipPath = path.join(cacheDir, `${binaryName}.zip`);
+
+  if (fs.existsSync(zipPath)) return zipPath;
+
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  const manifest = await fetchJson(`${R2_BASE_URL}/binaries/${BINARY_TAG}/manifest.json`);
+  const binaryInfo = manifest.platforms?.[platform]?.[binaryName];
+
+  if (!binaryInfo) {
+    throw new Error(`Binary ${binaryName} not available for ${platform}`);
+  }
+
+  const url = `${R2_BASE_URL}/binaries/${BINARY_TAG}/${platform}/${binaryName}.zip`;
+  await downloadFile(url, zipPath, binaryInfo.sha256, onProgress);
+
+  return zipPath;
+}
+
+async function getLatestVersion() {
+  const manifest = await fetchJson(`${R2_BASE_URL}/binaries/manifest.json`);
+  return manifest.latest;
+}
+
+module.exports = { R2_BASE_URL, BINARY_TAG, CACHE_DIR, LOCAL_DEV_MODE, LOCAL_DIST_DIR, ensureBinary, getLatestVersion };

package/dist/manifest.json

@@ -0,0 +1,4 @@
+{
+  "version": "v0.1.0-20260122005346",
+  "platforms": {}
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "better-coder",
+  "version": "0.1.0",
+  "description": "NPX wrapper for better-coder desktop app - prompt AI agents against local git repos",
+  "main": "index.js",
+  "bin": {
+    "better-coder": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "adm-zip": "^0.5.16"
+  },
+  "keywords": [
+    "tauri",
+    "desktop",
+    "agent",
+    "mcp",
+    "ai",
+    "coding"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/user/better-coder"
+  }
+}