@zatsepin/jigor 0.1.1

package/README.md

@@ -0,0 +1,43 @@
+# jigor-cli — the `jigor` binary (CLI + HTTP gateway)
+
+Ask System One decision models from the terminal or over HTTP. `von` and
+`laya` run locally as ONNX; `jev` runs remote on OpenRouter Decisions — one
+wire protocol across all of them: `noul`/`choice`/`score` questions in,
+typed answers out.
+
+```bash
+cargo install jigor-cli      # or: npm install --global @zatsepin/jigor  /  pip install jigor
+jigor serve --host 127.0.0.1 --port 8000   # HTTP gateway: POST /v1/systemone, GET /healthz
+jigor ask [--model <id>] [--provider <p>]  # the same wire over stdin, no HTTP layer
+jigor models                               # provider x model pairs
+```
+
+Model aliases: `von`, `laya`, `jev`, `jev-latest`. The local ONNX models
+download to `~/.cache/huggingface` on first use; set `OPENROUTER_API_KEY`
+for the remote `jev` backend.
+
+## Example
+
+```bash
+jigor ask --model von <<'JSON'
+{
+  "state": { "error": "Disk volume /var/log at 98% capacity." },
+  "questions": {
+    "requires_intervention": {
+      "type": "noul",
+      "instructions": "Does this disk space condition require operational intervention?"
+    }
+  }
+}
+JSON
+# {"model":"von-1.0.0","backend":"local","answers":{"requires_intervention":{"type":"noul","noul":0.2739}}}
+```
+
+## The jigor Rust library
+
+This binary is a thin shell over the
+[`jigor`](https://crates.io/crates/jigor) crate — local ONNX backends in
+`von`/`laya`, remote `jev` via OpenRouter Decisions, and one `answers()`
+call for all three. Use the library directly when you want decisions inside
+a Rust program: [crate docs](https://docs.rs/jigor) ·
+[full project README](https://github.com/Partysun/jigor#readme).

package/jigor

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+// Fallback shim. On Unix, `postinstall` replaces this file with the native
+// binary. On Windows, npm-generated global wrappers call this JS bin target
+// through node, so it must stay in place and spawn the `.exe`.
+
+const { spawn } = require("node:child_process");
+const { resolveBinaryPath } = require("./postinstall");
+
+if (process.platform !== "win32") {
+  console.error(
+    "[warn] postinstall script did not run; falling back to runtime binary resolution.",
+  );
+  console.error("Enable postinstall to avoid the per-invocation overhead.");
+}
+
+const binaryPath = resolveBinaryPath();
+if (!binaryPath) {
+  console.error(
+    "[jigor] Failed to locate the native binary. " +
+      "Ensure optional dependencies are installed (do not pass --no-optional).",
+  );
+  process.exit(1);
+}
+
+const child = spawn(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+
+child.on("error", (error) => {
+  console.error("[jigor] Failed to execute native binary:", error);
+  process.exit(1);
+});
+
+const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+const handlers = signals.map((signal) => {
+  const handler = () => {
+    if (!child.killed) {
+      try { child.kill(signal); } catch (_) {}
+    }
+  };
+  process.on(signal, handler);
+  return [signal, handler];
+});
+
+child.on("exit", (code, signal) => {
+  for (const [s, h] of handlers) process.removeListener(s, h);
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code == null ? 1 : code);
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@zatsepin/jigor",
+  "version": "0.1.1",
+  "description": "System One decision gateway CLI + server — von/laya local ONNX backends, jev on OpenRouter Decisions. One wire protocol: noul/choice/score questions in, typed answers out.",
+  "homepage": "https://github.com/Partysun/jigor",
+  "repository": "https://github.com/Partysun/jigor",
+  "license": "Apache-2.0",
+  "keywords": [
+    "system-one",
+    "decisions",
+    "onnx",
+    "cli",
+    "gateway"
+  ],
+  "engines": {
+    "node": ">= 18.0.0"
+  },
+  "files": [
+    "jigor",
+    "postinstall.js"
+  ],
+  "dependencies": {
+    "detect-libc": "2.1.2"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "optionalDependencies": {
+    "@zatsepin/jigor-darwin": "0.1.1",
+    "@zatsepin/jigor-linux-arm64-gnu": "0.1.1",
+    "@zatsepin/jigor-linux-x64-gnu": "0.1.1",
+    "@zatsepin/jigor-win32-x64-msvc": "0.1.1"
+  },
+  "bin": {
+    "jigor": "jigor"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/postinstall.js

@@ -0,0 +1,94 @@
+// Port of ast-grep's @ast-grep/cli postinstall: locate the native `jigor`
+// binary for the current platform (a platform package installed as an
+// optional dependency, or a local `target/release|debug/jigor` dev build)
+// and hard-link it over the JS shims.
+const fs = require("fs");
+const path = require("path");
+
+const binaryName = process.platform === "win32" ? "jigor.exe" : "jigor";
+
+function detectPackageName() {
+  const { platform, arch } = process;
+  switch (platform) {
+    case "darwin":
+      // one universal2 fat binary covers Intel (x64) and Apple Silicon (arm64)
+      if (arch === "x64" || arch === "arm64") return "@zatsepin/jigor-darwin";
+      break;
+    case "linux": {
+      const { MUSL, familySync } = require("detect-libc");
+      if (familySync() === MUSL) return null;
+      if (arch === "arm64") return "@zatsepin/jigor-linux-arm64-gnu";
+      if (arch === "x64") return "@zatsepin/jigor-linux-x64-gnu";
+      break;
+    }
+    case "win32":
+      if (arch === "x64") return "@zatsepin/jigor-win32-x64-msvc";
+      break;
+  }
+  return null;
+}
+
+function resolveBinaryDir() {
+  const pkgName = detectPackageName();
+  if (pkgName) {
+    try {
+      const dir = path.dirname(
+        require.resolve(`${pkgName}/package.json`, { paths: [__dirname] }),
+      );
+      if (fs.existsSync(path.join(dir, binaryName))) return dir;
+    } catch (_) {
+      // fall through to local dev paths
+    }
+  }
+  for (const profile of ["release", "debug"]) {
+    const dir = path.join(__dirname, "..", "target", profile);
+    if (fs.existsSync(path.join(dir, binaryName))) return dir;
+  }
+  return null;
+}
+
+function resolveBinaryPath() {
+  const dir = resolveBinaryDir();
+  return dir ? path.join(dir, binaryName) : null;
+}
+
+function installBinary(src, dest) {
+  try {
+    fs.linkSync(src, dest);
+  } catch (_) {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+function main() {
+  const sourceDir = resolveBinaryDir();
+  if (!sourceDir) {
+    console.error(
+      "[jigor] No native binary found for " +
+        `${process.platform ?? "?"}/${process.arch ?? "?"}. ` +
+        "Supported: linux x64/arm64 (glibc), macos (universal2: Intel + Apple Silicon), windows x64. " +
+        "Musl and other platforms are not packaged yet.",
+    );
+    process.exit(1);
+  }
+
+  const src = path.join(sourceDir, binaryName);
+  const destBin = path.join(__dirname, binaryName);
+  try {
+    installBinary(src, destBin);
+  } catch (_) {
+    console.error("[jigor] Failed to move the native binary into place.");
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  binaryName,
+  detectPackageName,
+  resolveBinaryDir,
+  resolveBinaryPath,
+};
+
+if (require.main === module) {
+  main();
+}