kannaka 0.11.1

package/README.md

@@ -0,0 +1,40 @@
+# kannaka
+
+Wave-interference (Holographic Resonance Medium) memory for AI agents — the
+native `kannaka` CLI, distributed over npm.
+
+```sh
+# one-off, no install
+npx kannaka --version
+
+# or install globally
+npm install -g kannaka
+kannaka remember "the grid hums at 72.83Hz" --importance 0.8
+kannaka recall "what frequency" --top-k 5
+```
+
+## How it works
+
+This package ships a tiny launcher. On install, its `postinstall` step
+downloads the native `kannaka` binary for your platform from the matching
+[GitHub release](https://github.com/NickFlach/kannaka-memory/releases),
+verifies its published `sha256`, and places it next to the launcher. No native
+binary is bundled in the tarball, so one small package serves every platform.
+
+Supported platforms: **linux**, **macOS**, **windows** on **x86_64** and
+**aarch64** (Linux builds are static musl, so they run on any distro).
+
+## Environment
+
+- `KANNAKA_SKIP_DOWNLOAD=1` — skip the postinstall download (offline / CI /
+  source builds). The launcher then reports the binary is missing until you
+  provide one.
+- `KANNAKA_DATA_DIR` — where the HRM store lives (default `~/.kannaka`).
+
+## Alternatives
+
+- Direct install script: `curl -sSf https://install.ninja-portal.com/kannaka | sh`
+- Docker: `docker run --rm ghcr.io/nickflach/kannaka --version`
+- Build from source: <https://github.com/NickFlach/kannaka-memory>
+
+MIT licensed. The version of this package tracks the kannaka release it installs.

package/bin/kannaka.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * Thin launcher: exec the native kannaka binary fetched by install.js, passing
+ * through argv and forwarding its exit code / signals. Keeps `npx kannaka` and
+ * a global install behaving exactly like the native CLI.
+ */
+"use strict";
+
+const { spawnSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const ext = process.platform === "win32" ? ".exe" : "";
+const bin = path.join(__dirname, `kannaka-bin${ext}`);
+
+if (!fs.existsSync(bin)) {
+  console.error(
+    "kannaka: native binary not found — the postinstall download did not run or failed.\n" +
+      "Reinstall with network access (e.g. `npm install -g kannaka`), or install directly:\n" +
+      "  curl -sSf https://install.ninja-portal.com/kannaka | sh",
+  );
+  process.exit(1);
+}
+
+const res = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" });
+if (res.error) {
+  console.error(`kannaka: ${res.error.message}`);
+  process.exit(1);
+}
+if (res.signal) {
+  // Re-raise the terminating signal so shells report it correctly.
+  process.kill(process.pid, res.signal);
+  return;
+}
+process.exit(res.status == null ? 1 : res.status);

package/install.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * Postinstall: fetch the platform-matched native `kannaka` binary from the
+ * GitHub release that matches this package's version, verify its published
+ * sha256, and drop it next to the launcher. No native binary is shipped inside
+ * the npm tarball — it is downloaded here so one small package serves every
+ * platform.
+ *
+ * Env:
+ *   KANNAKA_SKIP_DOWNLOAD=1   skip the download (CI / offline / source builds)
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const crypto = require("crypto");
+
+const pkg = require("./package.json");
+const VERSION = pkg.version;
+const REPO = "NickFlach/kannaka-memory";
+
+const OS_MAP = { linux: "linux", darwin: "macos", win32: "windows" };
+const ARCH_MAP = { x64: "x86_64", arm64: "aarch64" };
+
+function target() {
+  const os = OS_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+  if (!os || !arch) {
+    throw new Error(
+      `unsupported platform ${process.platform}/${process.arch}. Prebuilt ` +
+        `kannaka binaries exist for linux/macos/windows on x86_64/aarch64. ` +
+        `Build from source: https://github.com/${REPO}`,
+    );
+  }
+  const ext = process.platform === "win32" ? ".exe" : "";
+  return { os, arch, ext };
+}
+
+/** GET a URL, following GitHub's redirect to the asset CDN, resolving to a Buffer. */
+function get(url, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    if (redirects > 5) return reject(new Error("too many redirects"));
+    https
+      .get(url, { headers: { "User-Agent": "kannaka-npm-installer" } }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          res.resume();
+          resolve(get(res.headers.location, redirects + 1));
+          return;
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+          return;
+        }
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      })
+      .on("error", reject);
+  });
+}
+
+async function main() {
+  if (process.env.KANNAKA_SKIP_DOWNLOAD === "1") {
+    console.log("kannaka: KANNAKA_SKIP_DOWNLOAD=1 — skipping binary download.");
+    return;
+  }
+
+  const { os, arch, ext } = target();
+  const asset = `kannaka-${os}-${arch}${ext}`;
+  const base = `https://github.com/${REPO}/releases/download/v${VERSION}`;
+  const binDir = path.join(__dirname, "bin");
+  fs.mkdirSync(binDir, { recursive: true });
+  const dest = path.join(binDir, `kannaka-bin${ext}`);
+
+  console.log(`kannaka: downloading ${asset} (v${VERSION})…`);
+  const bin = await get(`${base}/${asset}`);
+
+  // Verify against the published <asset>.sha256 (format: "<hex>  <name>" or bare hex).
+  try {
+    const shaText = (await get(`${base}/${asset}.sha256`)).toString("utf8").trim();
+    const expected = shaText.split(/\s+/)[0].toLowerCase();
+    const actual = crypto.createHash("sha256").update(bin).digest("hex");
+    if (expected && expected !== actual) {
+      throw new Error(`sha256 mismatch for ${asset}: expected ${expected}, got ${actual}`);
+    }
+    console.log("kannaka: sha256 verified.");
+  } catch (e) {
+    if (String(e && e.message).includes("mismatch")) throw e;
+    console.warn(`kannaka: could not verify sha256 (${e && e.message}); proceeding.`);
+  }
+
+  fs.writeFileSync(dest, bin);
+  if (process.platform !== "win32") fs.chmodSync(dest, 0o755);
+  console.log(`kannaka: installed ${dest}`);
+}
+
+main().catch((e) => {
+  console.error(`kannaka: install failed: ${e && e.message}`);
+  console.error(
+    "You can retry with network access, or install the binary directly:\n" +
+      "  curl -sSf https://install.ninja-portal.com/kannaka | sh",
+  );
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "kannaka",
+  "version": "0.11.1",
+  "description": "Kannaka — wave-interference (Holographic Resonance Medium) memory for AI agents. Installs the native `kannaka` CLI.",
+  "bin": {
+    "kannaka": "bin/kannaka.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "files": [
+    "bin/kannaka.js",
+    "install.js",
+    "README.md"
+  ],
+  "keywords": [
+    "kannaka",
+    "memory",
+    "agent",
+    "hrm",
+    "holographic",
+    "resonance",
+    "wave-interference",
+    "vector",
+    "cli"
+  ],
+  "homepage": "https://github.com/NickFlach/kannaka-memory#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NickFlach/kannaka-memory.git"
+  },
+  "bugs": {
+    "url": "https://github.com/NickFlach/kannaka-memory/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}