@calliopelabs/cli 3.1.0 → 3.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calliopelabs/cli",
-  "version": "3.1.0",
+  "version": "3.2.1",
   "description": "The private-AI agent CLI - one terminal agent for any model backend, including the ones you run yourself",
   "keywords": [
     "ai",
@@ -33,7 +33,8 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "scripts/verify-runlog.mjs"
   ],
   "scripts": {
     "build": "tsc && chmod +x dist/bin.js",
@@ -47,22 +48,30 @@
     "bench:binary": "npm run build && bun packaging/build-binary.mjs --native && CALLIOPE_BENCH_BINARY=packaging/dist/calliope-native node bench/cold-start.mjs",
     "bench:ui": "vitest run -c bench/vitest.bench.config.ts bench/keystroke.bench.test.ts",
     "bench:mem": "NODE_OPTIONS=--expose-gc vitest run -c bench/vitest.bench.config.ts bench/memory.bench.test.ts",
-    "prepublishOnly": "npm run build && npm test"
+    "prepublishOnly": "npm run build && npm test && npm run test:conformance:release",
+    "test:conformance": "vitest run tests/provider-conformance.test.ts tests/provider-captures.test.ts tests/provider-readiness.test.ts tests/provider-probe-budget.test.ts tests/provider-semantic.test.ts tests/provider-semantic-recorder.test.ts tests/provider-semantic-captures.test.ts tests/provider-semantic-cli.test.ts",
+    "test:conformance:release": "CALLIOPE_REQUIRE_WIRE_CAPTURES=1 CALLIOPE_RELEASE_DEFERRED_PROVIDERS=xai npm run test:conformance",
+    "capture:provider": "npm run build && node scripts/conformance/capture.mjs",
+    "providers:readiness": "npm run build && node scripts/conformance/report.mjs",
+    "capture:semantics": "npm run build && node scripts/conformance/capture-semantic.mjs"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "0.111.0",
-    "@google/generative-ai": "^0.24.1",
+    "@google/genai": "^2.22.0",
     "@inquirer/prompts": "^8.5.2",
     "@zed-industries/agent-client-protocol": "^0.4.5",
     "conf": "^15.1.0",
     "ink": "^7.1.0",
     "openai": "^6.46.0",
     "react": "^19.2.3",
+    "sql.js": "1.14.2",
+    "string-width": "8.2.2",
     "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",
     "@types/react": "^19.2.7",
+    "@types/sql.js": "1.4.11",
     "@vitest/coverage-v8": "^4.0.16",
     "ink-testing-library": "^4.0.0",
     "sharp": "^0.35.3",

package/scripts/verify-runlog.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/** Independent v1 run-log verifier: only Node built-ins, no Calliope imports/state/network. */
+import { createReadStream, realpathSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { parseArgs } from "node:util";
+import { pathToFileURL } from "node:url";
+import { setImmediate } from "node:timers/promises";
+export const LIMITS = {
+  bytes: 64 * 1024 * 1024,
+  line: 1024 * 1024,
+  events: 100000,
+  depth: 64,
+};
+// ECMAScript UTF-16 key order and JSON.stringify primitive spelling are part of v1.
+export function canonical(value, depth = 0) {
+  if (depth > LIMITS.depth) throw new Error("nesting-limit");
+  if (typeof value === "number" && !Number.isFinite(value))
+    throw new Error("invalid-number");
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value))
+    return "[" + value.map((v) => canonical(v, depth + 1)).join(",") + "]";
+  return (
+    "{" +
+    Object.keys(value)
+      .sort()
+      .map((k) => JSON.stringify(k) + ":" + canonical(value[k], depth + 1))
+      .join(",") +
+    "}"
+  );
+}
+export async function verifyRunLog(
+  file,
+  { expectedHead, expectedCount, signal } = {},
+) {
+  const anchored = expectedHead !== undefined && expectedCount !== undefined;
+  if (
+    (expectedHead !== undefined || expectedCount !== undefined) &&
+    (!anchored ||
+      !/^[a-f0-9]{64}$/.test(expectedHead) ||
+      !Number.isSafeInteger(expectedCount) ||
+      expectedCount < 1 ||
+      expectedCount > LIMITS.events)
+  )
+    throw new Error("invalid-anchor");
+  const result = {
+    version: 1,
+    type: "runlog-verification",
+    ok: false,
+    anchored,
+    events: 0,
+    head: null,
+  };
+  const fail = (reason, line) => ({
+    ...result,
+    reason,
+    ...(line ? { line } : {}),
+  });
+  signal?.throwIfAborted();
+  const info = await stat(file);
+  if (!info.isFile() || info.size > LIMITS.bytes) return fail("file-limit");
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of createReadStream(file, {
+    signal,
+    highWaterMark: 65536,
+  })) {
+    size += chunk.length;
+    if (size > LIMITS.bytes) return fail("file-limit");
+    chunks.push(chunk);
+  }
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+      Buffer.concat(chunks),
+    );
+  } catch {
+    return fail("invalid-utf8");
+  }
+  if (!text.endsWith("\n")) return fail("missing-final-newline");
+  const lines = text.slice(0, -1).split("\n");
+  if (lines.length > LIMITS.events) return fail("event-limit");
+  let previous = "";
+  for (let i = 0; i < lines.length; i++) {
+    if (i % 100 === 0) {
+      await setImmediate();
+      signal?.throwIfAborted();
+    }
+    if (!lines[i].trim() || Buffer.byteLength(lines[i]) > LIMITS.line)
+      return fail("line-limit", i + 1);
+    let event;
+    try {
+      event = JSON.parse(lines[i]);
+    } catch {
+      return fail("invalid-json", i + 1);
+    }
+    if (
+      !event ||
+      typeof event !== "object" ||
+      Array.isArray(event) ||
+      event.v !== 1 ||
+      event.seq !== i ||
+      typeof event.ts !== "string" ||
+      !Number.isFinite(Date.parse(event.ts)) ||
+      typeof event.type !== "string" ||
+      !event.type ||
+      !/^[a-f0-9]{64}$/.test(event.hash)
+    )
+      return fail("invalid-event", i + 1);
+    const { prev_hash, hash, ...body } = event;
+    if (prev_hash !== previous) return fail("prev-hash-mismatch", i + 1);
+    let serialized;
+    try {
+      serialized = canonical(body);
+    } catch (error) {
+      return fail(error.message, i + 1);
+    }
+    if (
+      createHash("sha256")
+        .update(previous + serialized, "utf8")
+        .digest("hex") !== hash
+    )
+      return fail("hash-mismatch", i + 1);
+    result.events++;
+    result.head = hash;
+    previous = hash;
+  }
+  if (!result.events) return fail("empty-log");
+  if (
+    anchored &&
+    (result.head !== expectedHead || result.events !== expectedCount)
+  )
+    return fail("anchor-mismatch");
+  return { ...result, ok: true };
+}
+function isEntrypoint() {
+  try {
+    // Node resolves linked package paths before setting import.meta.url.
+    return (
+      import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href
+    );
+  } catch {
+    // Importers using stdin/eval may have no filesystem entry point.
+    return false;
+  }
+}
+if (isEntrypoint()) {
+  const signal = new AbortController();
+  const abort = () =>
+    signal.abort(new DOMException("Verification cancelled", "AbortError"));
+  process.once("SIGINT", abort);
+  process.once("SIGTERM", abort);
+  let json = process.argv.includes("--json");
+  try {
+    const { values, positionals } = parseArgs({
+      allowPositionals: true,
+      options: {
+        json: { type: "boolean" },
+        help: { type: "boolean" },
+        "expected-head": { type: "string" },
+        "expected-count": { type: "string" },
+      },
+    });
+    if (values.help) {
+      console.log(
+        "Usage: node verify-runlog.mjs <trace.jsonl> [--json] [--expected-head <sha256> --expected-count <events>]",
+      );
+    } else {
+      if (
+        positionals.length !== 1 ||
+        (values["expected-count"] !== undefined &&
+          !/^[1-9][0-9]*$/.test(values["expected-count"]))
+      )
+        throw new Error("invalid-arguments");
+      const result = await verifyRunLog(positionals[0], {
+        expectedHead: values["expected-head"],
+        expectedCount:
+          values["expected-count"] === undefined
+            ? undefined
+            : Number(values["expected-count"]),
+        signal: signal.signal,
+      });
+      console.log(
+        json
+          ? JSON.stringify(result)
+          : `${result.ok ? "OK" : "FAILED"}: ${result.events} events; ${result.anchored ? "trusted anchor checked" : "unanchored chain only"}${result.reason ? `; ${result.reason}` : ""}`,
+      );
+      process.exitCode = result.ok ? 0 : 4;
+    }
+  } catch (error) {
+    const reason = signal.signal.aborted
+      ? "cancelled"
+      : ["invalid-anchor", "invalid-arguments"].includes(error.message)
+        ? error.message
+        : "unreadable-or-invalid-input";
+    const result = {
+      version: 1,
+      type: "runlog-verification",
+      ok: false,
+      reason,
+    };
+    console.log(json ? JSON.stringify(result) : `FAILED: ${reason}`);
+    process.exitCode = signal.signal.aborted ? 130 : 1;
+  } finally {
+    process.removeListener("SIGINT", abort);
+    process.removeListener("SIGTERM", abort);
+  }
+}