mochiii 0.0.0-stage → 1.2.2

package/bin/mochiii

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// The `mochiii` command of the npm package: it runs the native binary from the
+// platform package npm installed beside it (@mochiii/<platform>).
+//
+// On macOS and Linux this file is usually not what runs: the package's
+// postinstall (install.js) replaces it with the binary itself, so starting
+// mochiii costs no Node. It runs when install scripts were off (npm
+// --ignore-scripts, pnpm by default) and always on Windows, where npm starts
+// every package command through Node.
+'use strict';
+
+const { spawn } = require('child_process');
+const { findBinary } = require('../platform.js');
+
+let bin;
+try {
+  bin = findBinary();
+} catch (err) {
+  console.error(`mochiii: ${err.message}`);
+  process.exit(1);
+}
+
+// The terminal, signals and exit status all belong to the binary. Ctrl-C in a
+// terminal reaches it directly (the whole foreground process group gets it), so
+// this process ignores SIGINT rather than dying first; SIGTERM and SIGHUP, which
+// are sent to this process alone, are passed on.
+const child = spawn(bin, process.argv.slice(2), { stdio: 'inherit', windowsHide: false });
+process.on('SIGINT', () => {});
+for (const sig of ['SIGTERM', 'SIGHUP']) {
+  process.on(sig, () => child.kill(sig));
+}
+child.on('error', (err) => {
+  console.error(`mochiii: could not start ${bin}: ${err.message}`);
+  process.exit(1);
+});
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.removeAllListeners(signal);
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code === null ? 1 : code);
+});

package/install.js

@@ -0,0 +1,43 @@
+'use strict';
+
+// postinstall: put the native binary where the `mochiii` command points, so
+// that starting Mochiii does not start Node first.
+//
+// npm links the `mochiii` command to bin/mochiii, a small Node launcher. On
+// macOS and Linux this replaces that file with the binary from the platform
+// package -- a hard link where it can, else a copy -- the way esbuild's npm
+// package does. The binary needs nothing from Node: it is the one `mochiii`
+// program, and it finds its own background service and helper by its own path.
+//
+// It changes nothing on Windows, where npm starts every package command through
+// Node regardless, and it never fails the install: with no platform package,
+// or a file it cannot replace, the launcher stays, and the launcher says what is
+// missing when it runs.
+const fs = require('fs');
+const path = require('path');
+const { findBinary } = require('./platform.js');
+
+function main() {
+  if (process.platform === 'win32') return;
+  let bin;
+  try {
+    bin = findBinary();
+  } catch {
+    return; // the launcher will say why
+  }
+  const launcher = path.join(__dirname, 'bin', 'mochiii');
+  const tmp = `${launcher}.native.${process.pid}`;
+  try {
+    try {
+      fs.linkSync(bin, tmp);
+    } catch {
+      fs.copyFileSync(bin, tmp);
+    }
+    fs.chmodSync(tmp, 0o755);
+    fs.renameSync(tmp, launcher);
+  } catch {
+    try { fs.unlinkSync(tmp); } catch { /* nothing to remove */ }
+  }
+}
+
+main();

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "mochiii",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Mochiii: the terminal coding assistant that knows your codebase.",
+  "version": "1.2.2",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://github.com/Rav-2007/codeterminal-core",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rav-2007/codeterminal-core.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rav-2007/codeterminal-core/issues"
+  },
+  "keywords": [
+    "ai",
+    "coding-assistant",
+    "terminal",
+    "cli",
+    "agent",
+    "code-search"
+  ],
+  "bin": {
+    "mochiii": "bin/mochiii"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "optionalDependencies": {
+    "@mochiii/linux-x64": "1.2.2",
+    "@mochiii/win32-x64": "1.2.2",
+    "@mochiii/darwin-arm64": "1.2.2",
+    "@mochiii/linux-arm64": "1.2.2",
+    "@mochiii/linux-x64-musl": "1.2.2",
+    "@mochiii/linux-arm64-musl": "1.2.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "install.js",
+    "platform.js",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_LICENSES.txt"
+  ]
+}

package/platform.js

@@ -0,0 +1,75 @@
+'use strict';
+
+// Which @mochiii/<platform> package carries the binary for this computer.
+//
+// Windows on ARM runs the x64 build under Windows' own emulation, so win32-x64
+// declares both CPUs. Intel Macs have no package: onnxruntime, which runs the
+// code-search model, publishes no Intel Mac build. Linux has two packages per
+// CPU: the regular build, which needs glibc, and the static -musl build without
+// code search, for Alpine and other musl systems; their `libc` fields let npm
+// install only the one that fits.
+
+const path = require('path');
+
+// The platform packages, as npm/build.js makes them. Kept here, beside the
+// mapping that reads it; build.js checks the two agree.
+const SUPPORTED = ['linux-x64', 'linux-arm64', 'darwin-arm64', 'win32-x64', 'linux-x64-musl', 'linux-arm64-musl'];
+
+// The packages that could carry this computer's binary, best first: on Linux
+// the glibc build, then the musl one.
+function platformPackages(platform = process.platform, arch = process.arch) {
+  if (platform === 'darwin' && arch !== 'arm64') {
+    throw new Error("Intel Macs aren't supported: onnxruntime, which runs Mochiii's code search, has no Intel Mac build.");
+  }
+  const cpu = platform === 'win32' ? 'x64' : arch;
+  const base = `${platform}-${cpu}`;
+  const names = [base, `${base}-musl`].filter((n) => SUPPORTED.includes(n));
+  if (names.length === 0) {
+    throw new Error(`there is no Mochiii build for ${platform}/${arch} (there are builds for ${SUPPORTED.join(', ')}).`);
+  }
+  return names.map((n) => `@mochiii/${n}`);
+}
+
+// The package for this computer, given whether its libc is musl.
+function platformPackage(platform = process.platform, arch = process.arch, musl = false) {
+  const names = platformPackages(platform, arch);
+  return (musl && names.find((n) => n.endsWith('-musl'))) || names[0];
+}
+
+// The binary inside a platform package, given that package's package.json.
+function binaryPath(packageJSON, platform = process.platform) {
+  return path.join(path.dirname(packageJSON), 'bin', platform === 'win32' ? 'mochiii.exe' : 'mochiii');
+}
+
+// Whether this Linux runs on musl rather than glibc. Asking costs about 10 ms,
+// so it is asked only when npm installed both Linux packages, as an npm too old
+// to read `libc` does.
+function usesMusl() {
+  try {
+    return process.platform === 'linux' && !process.report.getReport().header.glibcVersionRuntime;
+  } catch {
+    return false;
+  }
+}
+
+// The installed binary for this computer, or an Error that says, to whoever
+// typed `mochiii`, why there is none.
+function findBinary() {
+  const found = [];
+  for (const pkg of platformPackages()) {
+    try {
+      found.push([pkg, binaryPath(require.resolve(`${pkg}/package.json`))]);
+    } catch (err) {
+      if (err.code !== 'MODULE_NOT_FOUND') throw err;
+    }
+  }
+  if (found.length === 1) return found[0][1];
+  if (found.length > 1) {
+    const want = platformPackage(process.platform, process.arch, usesMusl());
+    return found.find(([pkg]) => pkg === want)[1];
+  }
+  throw new Error(`the package for this computer (${platformPackage(process.platform, process.arch, usesMusl())}) ` +
+    'is not installed. Reinstall with: npm install -g mochiii');
+}
+
+module.exports = { platformPackage, platformPackages, binaryPath, findBinary, usesMusl, SUPPORTED };