@mathew-cf/rag-cli 0.0.0-bootstrap.0

package/README.md

@@ -0,0 +1,24 @@
+# @mathew-cf/rag-cli
+
+Local-first RAG CLI — semantic search over your files using local embeddings. All inference runs on your machine; no external API calls.
+
+```bash
+npm install -g @mathew-cf/rag-cli
+
+rag index ./my-project
+rag search "how does authentication work"
+```
+
+On install, npm fetches the prebuilt binary for your platform via `optionalDependencies`. Supported platforms: macOS ARM64, macOS x86_64, Linux x86_64, Linux ARM64.
+
+On any other platform, install from source instead:
+
+```bash
+cargo install rag-cli
+```
+
+For the full command reference, see the [project README](https://github.com/mathew-cf/rag-cli#readme).
+
+## License
+
+Apache-2.0

package/bin/rag.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Meta-package shim for @mathew-cf/rag-cli.
+ *
+ * Resolves the platform-specific subpackage at runtime and execs its
+ * `rag` binary. Signals are forwarded so Ctrl-C works; exit codes are
+ * propagated so shell scripts can branch on success/failure.
+ *
+ * The platform detection logic lives in ../src/platform.js so it's
+ * testable without spawning a process.
+ */
+
+"use strict";
+
+const { spawn } = require("node:child_process");
+const {
+  binaryFilename,
+  isSupported,
+  platformKey,
+  subpackageName,
+  unsupportedMessage,
+} = require("../src/platform");
+
+const key = platformKey(process.platform, process.arch);
+
+if (!isSupported(key)) {
+  process.stderr.write(`${unsupportedMessage(key)}\n`);
+  process.exit(1);
+}
+
+let binaryPath;
+try {
+  binaryPath = require.resolve(
+    `${subpackageName(key)}/bin/${binaryFilename(process.platform)}`,
+  );
+} catch {
+  process.stderr.write(
+    `@mathew-cf/rag-cli: platform package ${subpackageName(key)} is not installed.\n` +
+      `This usually means npm skipped optionalDependencies. Try:\n` +
+      `  npm install @mathew-cf/rag-cli --force\n`,
+  );
+  process.exit(1);
+}
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: "inherit",
+  windowsHide: false,
+});
+
+// Forward terminal signals to the child. Without this, ^C gets eaten by
+// the Node wrapper and the spawned binary keeps running.
+const forwardedSignals = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+for (const sig of forwardedSignals) {
+  process.on(sig, () => {
+    if (!child.killed) child.kill(sig);
+  });
+}
+
+child.on("error", (err) => {
+  process.stderr.write(`@mathew-cf/rag-cli: failed to exec binary: ${err.message}\n`);
+  process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    // Re-raise so the shell sees the canonical exit-via-signal (128+n).
+    process.kill(process.pid, signal);
+  } else {
+    process.exit(code ?? 1);
+  }
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@mathew-cf/rag-cli",
+  "version": "0.0.0-bootstrap.0",
+  "description": "Local-first RAG CLI — semantic search over your files using local embeddings",
+  "license": "Apache-2.0",
+  "author": "mathew-cf",
+  "homepage": "https://github.com/mathew-cf/rag-cli",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mathew-cf/rag-cli"
+  },
+  "keywords": [
+    "rag",
+    "semantic-search",
+    "embeddings",
+    "cli",
+    "local-first"
+  ],
+  "bin": {
+    "rag": "bin/rag.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "optionalDependencies": {
+    "@mathew-cf/rag-cli-darwin-arm64": "0.0.0-bootstrap.0",
+    "@mathew-cf/rag-cli-darwin-x64": "0.0.0-bootstrap.0",
+    "@mathew-cf/rag-cli-linux-x64": "0.0.0-bootstrap.0",
+    "@mathew-cf/rag-cli-linux-arm64": "0.0.0-bootstrap.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/platform.js

@@ -0,0 +1,83 @@
+/**
+ * Platform → subpackage mapping.
+ *
+ * Kept in its own module (and written as plain CommonJS) so:
+ *   - the shim at `bin/rag.js` can `require()` it at runtime
+ *   - unit tests can import it and call `platformKey()` with mocked
+ *     values without spawning a shell or a child process.
+ *
+ * Update SUPPORTED_PLATFORMS in lockstep with `npm/rag-cli/package.json`
+ * `optionalDependencies` and the release workflow's build matrix.
+ */
+
+"use strict";
+
+/**
+ * Compose the platform key used in subpackage names.
+ * Mirrors Node's `process.platform` + `process.arch` convention.
+ * Exported so tests can feed synthetic platform/arch values without
+ * mutating process globals.
+ */
+function platformKey(platform, arch) {
+  return `${platform}-${arch}`;
+}
+
+/**
+ * The set of platforms we publish prebuilt binaries for. Anything
+ * outside this set falls back to `cargo install rag-cli`.
+ */
+const SUPPORTED_PLATFORMS = Object.freeze([
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-x64",
+  "linux-arm64",
+]);
+
+/**
+ * @param {string} key — result of platformKey(platform, arch)
+ * @returns {boolean}
+ */
+function isSupported(key) {
+  return SUPPORTED_PLATFORMS.includes(key);
+}
+
+/**
+ * npm package name for a given platform key.
+ * The scope matches the meta package.
+ */
+function subpackageName(key) {
+  return `@mathew-cf/rag-cli-${key}`;
+}
+
+/**
+ * Name of the binary file inside a subpackage's `bin/` directory.
+ * Windows binaries would be `rag.exe`; Unix platforms use `rag`.
+ * Currently all supported platforms are Unix — this helper is the
+ * single place to update when/if win32 support lands.
+ */
+function binaryFilename(platform) {
+  return platform === "win32" ? "rag.exe" : "rag";
+}
+
+/**
+ * Build a human-readable diagnostic for unsupported platforms.
+ * Kept as a pure function so tests can snapshot the message.
+ */
+function unsupportedMessage(key) {
+  return [
+    `@mathew-cf/rag-cli: no prebuilt binary for ${key}.`,
+    `Supported platforms: ${SUPPORTED_PLATFORMS.join(", ")}.`,
+    ``,
+    `Fallback: install from source via Rust:`,
+    `  cargo install rag-cli`,
+  ].join("\n");
+}
+
+module.exports = {
+  platformKey,
+  isSupported,
+  subpackageName,
+  binaryFilename,
+  unsupportedMessage,
+  SUPPORTED_PLATFORMS,
+};