qmem-cli 0.1.1

package/README.md

@@ -0,0 +1,71 @@
+# smart-query npm wrapper
+
+This package provides an npm-installed `smart-query` launcher for the Rust CLI.
+
+## Current state
+
+This wrapper can now try to download a matching prebuilt binary during `npm install`.
+
+The launcher looks for a usable `smart-query` binary in this order:
+
+1. `SMART_QUERY_BIN`
+2. `npm/vendor/<platform>-<arch>/smart-query`
+3. `target/release/smart-query`
+4. `target/debug/smart-query`
+
+On Windows it looks for `smart-query.exe`.
+
+## Install behavior
+
+During `postinstall`, the package tries to fetch a release asset from:
+
+```text
+https://github.com/IAmMarcellus/smart-query/releases/download/v<version>/smart-query-v<version>-<target>.tar.gz
+```
+
+Current target mapping:
+- Linux x64 → `x86_64-unknown-linux-gnu`
+- Linux arm64 → `aarch64-unknown-linux-gnu`
+- macOS x64 → `x86_64-apple-darwin`
+- macOS arm64 → `aarch64-apple-darwin`
+- Windows x64 → `x86_64-pc-windows-msvc`
+- Windows arm64 → `aarch64-pc-windows-msvc`
+
+The downloaded archive is expected to extract a `smart-query` binary directly into the package vendor directory.
+
+## Useful environment variables
+
+- `SMART_QUERY_BIN` — bypass downloader and use an explicit binary path
+- `SMART_QUERY_SKIP_DOWNLOAD=1` — skip postinstall download attempt
+- `SMART_QUERY_RELEASE_BASE_URL` — override the GitHub Releases base URL
+
+## Local development
+
+From the repo root:
+
+```bash
+cargo build --release -p smart-query-cli
+npm --prefix npm link
+smart-query --help
+```
+
+Or point directly at an existing binary:
+
+```bash
+SMART_QUERY_BIN=/path/to/smart-query npm --prefix npm link
+smart-query --help
+```
+
+## Release packaging expectation
+
+To publish this wrapper for real `npm install -g smart-query` use, release assets should be uploaded with names like:
+
+```text
+smart-query-v0.1.1-x86_64-unknown-linux-gnu.tar.gz
+smart-query-v0.1.1-aarch64-apple-darwin.tar.gz
+smart-query-v0.1.1-x86_64-pc-windows-msvc.tar.gz
+```
+
+Each archive should unpack to a binary named:
+- `smart-query`
+- `smart-query.exe` on Windows

package/bin/smart-query.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const exeName = process.platform === 'win32' ? 'smart-query.exe' : 'smart-query';
+const wrapperDir = path.resolve(__dirname, '..');
+const candidatePaths = [
+  process.env.SMART_QUERY_BIN,
+  path.join(wrapperDir, 'vendor', process.platform + '-' + process.arch, exeName),
+  path.resolve(wrapperDir, '..', 'target', 'release', exeName),
+  path.resolve(wrapperDir, '..', 'target', 'debug', exeName),
+].filter(Boolean);
+
+const binaryPath = candidatePaths.find((candidate) => {
+  try {
+    return fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+});
+
+if (!binaryPath) {
+  console.error([
+    'smart-query: no packaged binary was found.',
+    '',
+    'This npm wrapper currently expects one of:',
+    '  - SMART_QUERY_BIN to point at a built smart-query binary, or',
+    '  - an auto-downloaded or vendored binary at npm/vendor/<platform>-<arch>/smart-query, or',
+    '  - a local repo build at target/release/smart-query or target/debug/smart-query.',
+    '',
+    'If postinstall download failed, build locally or set SMART_QUERY_BIN.',
+    '',
+    'Example local build flow:',
+    '  cargo build --release -p smart-query-cli',
+    '  npm --prefix npm link',
+  ].join('\n'));
+  process.exit(1);
+}
+
+const result = spawnSync(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+if (result.error) {
+  console.error(`smart-query: failed to launch ${binaryPath}`);
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "qmem-cli",
+  "version": "0.1.1",
+  "description": "qmem — fast local semantic + lexical search/retrieval CLI (Rust)",
+  "license": "MIT OR Apache-2.0",
+  "type": "commonjs",
+  "bin": {
+    "qmem": "bin/smart-query.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md"
+  ],
+  "keywords": [
+    "search",
+    "retrieval",
+    "cli",
+    "rust",
+    "memory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/IAmMarcellus/smart-query.git",
+    "directory": "npm"
+  },
+  "homepage": "https://github.com/IAmMarcellus/smart-query",
+  "bugs": {
+    "url": "https://github.com/IAmMarcellus/smart-query/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "postinstall": "node ./scripts/install.js",
+    "test": "node ./bin/smart-query.js --help"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const http = require('node:http');
+const https = require('node:https');
+const { pipeline } = require('node:stream');
+const { promisify } = require('node:util');
+const { spawnSync } = require('node:child_process');
+
+const streamPipeline = promisify(pipeline);
+const pkg = require('../package.json');
+
+const platformMap = {
+  linux: 'unknown-linux-gnu',
+  darwin: 'apple-darwin',
+  win32: 'pc-windows-msvc',
+};
+
+const archMap = {
+  x64: 'x86_64',
+  arm64: 'aarch64',
+};
+
+const platform = process.platform;
+const arch = process.arch;
+const targetPlatform = platformMap[platform];
+const targetArch = archMap[arch];
+const exeName = platform === 'win32' ? 'smart-query.exe' : 'smart-query';
+const wrapperRoot = path.resolve(__dirname, '..');
+const vendorDir = path.join(wrapperRoot, 'vendor', `${platform}-${arch}`);
+const vendorBinaryPath = path.join(vendorDir, exeName);
+
+function log(message) {
+  console.log(`smart-query postinstall: ${message}`);
+}
+
+function warn(message) {
+  console.warn(`smart-query postinstall: ${message}`);
+}
+
+function hasFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function getReleaseBaseUrl() {
+  if (process.env.SMART_QUERY_RELEASE_BASE_URL) {
+    return process.env.SMART_QUERY_RELEASE_BASE_URL.replace(/\/$/, '');
+  }
+  const version = pkg.version;
+  return `https://github.com/IAmMarcellus/smart-query/releases/download/v${version}`;
+}
+
+function getAssetName() {
+  if (!targetPlatform || !targetArch) {
+    return null;
+  }
+  return `smart-query-v${pkg.version}-${targetArch}-${targetPlatform}.tar.gz`;
+}
+
+function request(url) {
+  const client = url.startsWith('https:') ? https : http;
+  return new Promise((resolve, reject) => {
+    const req = client.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        resolve(request(res.headers.location));
+        return;
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+        return;
+      }
+      resolve(res);
+    });
+    req.on('error', reject);
+  });
+}
+
+async function download(url, destination) {
+  const res = await request(url);
+  await fs.promises.mkdir(path.dirname(destination), { recursive: true });
+  const file = fs.createWriteStream(destination);
+  await streamPipeline(res, file);
+}
+
+async function main() {
+  if (process.env.SMART_QUERY_SKIP_DOWNLOAD === '1') {
+    log('skipping download because SMART_QUERY_SKIP_DOWNLOAD=1');
+    return;
+  }
+
+  if (process.env.SMART_QUERY_BIN) {
+    log('skipping download because SMART_QUERY_BIN is set');
+    return;
+  }
+
+  if (hasFile(vendorBinaryPath)) {
+    log(`using existing vendored binary at ${vendorBinaryPath}`);
+    return;
+  }
+
+  const assetName = getAssetName();
+  if (!assetName) {
+    warn(`unsupported platform/arch for automatic download: ${platform}/${arch}`);
+    return;
+  }
+
+  const releaseBaseUrl = getReleaseBaseUrl();
+  const assetUrl = `${releaseBaseUrl}/${assetName}`;
+  const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'smart-query-install-'));
+  const archivePath = path.join(tmpDir, assetName);
+
+  try {
+    log(`downloading ${assetUrl}`);
+    await download(assetUrl, archivePath);
+    await fs.promises.mkdir(vendorDir, { recursive: true });
+
+    const tarArgs = platform === 'win32'
+      ? ['-xzf', archivePath, '-C', vendorDir]
+      : ['-xzf', archivePath, '-C', vendorDir];
+    const tar = spawnSync('tar', tarArgs, { stdio: 'inherit' });
+    if (tar.error) {
+      throw tar.error;
+    }
+    if (tar.status !== 0) {
+      throw new Error(`tar exited with status ${tar.status}`);
+    }
+
+    if (!hasFile(vendorBinaryPath)) {
+      throw new Error(`archive extracted, but ${vendorBinaryPath} was not found`);
+    }
+
+    if (platform !== 'win32') {
+      await fs.promises.chmod(vendorBinaryPath, 0o755);
+    }
+
+    log(`installed ${vendorBinaryPath}`);
+  } catch (error) {
+    warn(`automatic binary download failed: ${error.message}`);
+    warn('you can still use this package by setting SMART_QUERY_BIN or by building the Rust binary locally.');
+  }
+}
+
+main().catch((error) => {
+  warn(`unexpected install failure: ${error.message}`);
+  process.exit(0);
+});