@hypercarrier/rarebit 0.1.0-alpha.4 → 0.1.0-alpha.6

package/test/piq.test.mjs

@@ -0,0 +1,212 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile, writeFile, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { readPiSession } from "../src/pi-session.mjs";
+import {
+  queryPiQ,
+  queryPiSessionBranches,
+} from "../src/piq.mjs";
+import { parsePiQCliArgs } from "../src/piq-cli.mjs";
+
+const records = [
+  {
+    type: "session",
+    version: 3,
+    id: "piq-fixture",
+    timestamp: "2026-09-21T00:00:00.000Z",
+    cwd: "/private/project",
+    unknownHeader: { retained: true },
+  },
+  {
+    type: "message",
+    id: "root",
+    parentId: null,
+    timestamp: "2026-09-21T00:00:01.000Z",
+    message: { role: "user", content: "root" },
+    unknownEntryField: "kept",
+    _piq: { source: "native" },
+  },
+  {
+    type: "message",
+    id: "tool-call",
+    parentId: "root",
+    timestamp: "2026-09-21T00:00:02.000Z",
+    message: {
+      role: "assistant",
+      content: [
+        "unknown-content-block",
+        { type: "text", text: "calling" },
+        { type: "toolCall", id: "call-1", name: "search", arguments: { q: "x" } },
+      ],
+    },
+  },
+  {
+    type: "compaction",
+    id: "compact",
+    parentId: "tool-call",
+    timestamp: "2026-09-21T00:00:03.000Z",
+    firstKeptEntryId: "tool-call",
+    summary: "older context",
+    futureField: { retained: "raw" },
+  },
+  {
+    type: "message",
+    id: "tool-result",
+    parentId: "compact",
+    timestamp: "2026-09-21T00:00:04.000Z",
+    message: {
+      role: "toolResult",
+      toolCallId: "call-1",
+      content: [{ type: "text", text: "result" }],
+    },
+  },
+  {
+    type: "message",
+    id: "active",
+    parentId: "tool-result",
+    timestamp: "2026-09-21T00:00:05.000Z",
+    message: { role: "assistant", stopReason: "stop", content: "done" },
+  },
+  {
+    type: "message",
+    id: "sibling",
+    parentId: "root",
+    timestamp: "2026-09-21T00:00:06.000Z",
+    message: { role: "user", content: "sibling" },
+  },
+];
+
+async function fixture(testContext) {
+  const root = await mkdtemp(join(tmpdir(), "piq-"));
+  testContext.after(() => rm(root, { recursive: true, force: true }));
+  const file = join(root, "session.jsonl");
+  const source = records.map(JSON.stringify).join("\n") + "\n";
+  await writeFile(file, source);
+  return { file, root, source };
+}
+
+test("generic reader resolves the default and explicit branches without timestamps", async (t) => {
+  const { file } = await fixture(t);
+  const loaded = await readPiSession(file);
+  assert.deepEqual(loaded.branch.map((entry) => entry.id), ["root", "sibling"]);
+  const active = await readPiSession(file, { leafId: "active" });
+  assert.deepEqual(active.branch.map((entry) => entry.id), [
+    "root",
+    "tool-call",
+    "compact",
+    "tool-result",
+    "active",
+  ]);
+  const branches = queryPiSessionBranches(active);
+  assert.deepEqual(
+    branches.map((branch) => branch.leafId),
+    ["active", "sibling"],
+  );
+});
+
+test("PiQ preserves raw fields and filters evidence", async (t) => {
+  const { file, source } = await fixture(t);
+  const entries = await queryPiQ(file, { kind: "entries", leafId: "active" });
+  assert.equal(entries[0].entry.unknownEntryField, "kept");
+  assert.equal(entries[0].entry._piq.source, "native");
+  assert.equal(entries[1]._piq.branchLeafId, "active");
+  const roles = await queryPiQ(file, { kind: "entries", leafId: "active", role: "toolResult" });
+  assert.deepEqual(roles.map((record) => record.entry.id), ["tool-result"]);
+  const tools = await queryPiQ(file, { kind: "tools", leafId: "active" });
+  assert.deepEqual(tools.map((record) => record._piq.kind), ["tool-call", "tool-result"]);
+  assert.equal(tools[0]._piq.blockIndex, 2);
+  const boundaries = await queryPiQ(file, { kind: "compactions", leafId: "active" });
+  assert.equal(boundaries[0].entry.futureField.retained, "raw");
+  const filteredBoundary = await queryPiQ(file, {
+    kind: "compactions",
+    leafId: "active",
+    entryId: "compact",
+    from: "2026-09-21T00:00:03.000Z",
+    to: "2026-09-21T00:00:03.000Z",
+  });
+  assert.equal(filteredBoundary.length, 1);
+  const prior = await queryPiQ(file, {
+    kind: "entries",
+    leafId: "active",
+    throughCompaction: "compact",
+  });
+  assert.deepEqual(prior.map((record) => record.entry.id), ["root", "tool-call", "compact"]);
+  const dated = await queryPiQ(file, {
+    kind: "entries",
+    leafId: "active",
+    from: "2026-09-21T00:00:04.000Z",
+  });
+  assert.deepEqual(dated.map((record) => record.entry.id), ["tool-result", "active"]);
+  const epochRange = await queryPiQ(file, {
+    kind: "entries",
+    leafId: "active",
+    from: "1970-01-01T00:00:00.000Z",
+    to: "1970-01-01T00:00:00.000Z",
+  });
+  assert.deepEqual(epochRange, []);
+  assert.equal(await readFile(file, "utf8"), source);
+});
+
+test("PiQ CLI emits JSONL and rejects malformed or ambiguous branch choices", async (t) => {
+  const { file, root } = await fixture(t);
+  const parsed = parsePiQCliArgs([
+    "entries",
+    "--session",
+    file,
+    "--leaf",
+    "sibling",
+    "--role",
+    "user",
+  ]);
+  assert.equal(parsed.leafId, "sibling");
+  const cli = new URL("../bin/piq.mjs", import.meta.url);
+  const output = spawnSync(
+    process.execPath,
+    [cli.pathname, "entries", "--session", file, "--leaf", "sibling"],
+    { encoding: "utf8" },
+  );
+  assert.equal(output.status, 0, output.stderr);
+  assert.deepEqual(
+    output.stdout.trim().split("\n").map((line) => JSON.parse(line).entry.id),
+    ["root", "sibling"],
+  );
+  const unsupported = spawnSync(
+    process.execPath,
+    [cli.pathname, "branches", "--session", file, "--role", "user"],
+    { encoding: "utf8" },
+  );
+  assert.notEqual(unsupported.status, 0);
+  assert.match(unsupported.stderr, /Branch listing does not support filters/);
+  await assert.rejects(
+    queryPiQ(file, { kind: "entries", leafId: "missing" }),
+    /no Session entry with leaf ID missing/i,
+  );
+  await assert.rejects(
+    queryPiQ(file, { kind: "entries", from: "not-a-date" }),
+    /ISO-8601 timestamp/,
+  );
+  await assert.rejects(
+    queryPiQ(file, { kind: "branches", role: "user" }),
+    /does not support filters/,
+  );
+  await assert.rejects(
+    queryPiQ(file, { kind: "branches", leafId: "active" }),
+    /does not support --leaf/,
+  );
+  const malformed = join(root, "malformed.jsonl");
+  await writeFile(malformed, `${JSON.stringify(records[0])}\n{bad\n`);
+  await assert.rejects(queryPiQ(malformed), /malformed JSON/);
+  const cycle = join(root, "cycle.jsonl");
+  await writeFile(
+    cycle,
+    [
+      { type: "session", version: 3, id: "cycle" },
+      { type: "message", id: "a", parentId: "b", message: { role: "user", content: "a" } },
+      { type: "message", id: "b", parentId: "a", message: { role: "user", content: "b" } },
+    ].map(JSON.stringify).join("\n"),
+  );
+  await assert.rejects(queryPiQ(cycle, { kind: "branches" }), /cycle/);
+});

package/test/rarebit-command.test.mjs

@@ -14,11 +14,11 @@ const values = (prefix) =>
 test("one grammar derives command description and usage", () => {
   assert.equal(
     rarebitCommandDescription(),
-    "Rarebit status/recall/config/auto-title/title/summarize",
+    "Rarebit status/recall/fork/config/auto-title/title/summarize",
   );
   assert.equal(
     rarebitCommandUsage(),
-    "Usage: /rarebit [status|recall|config|auto-title|title|summarize]",
+    "Usage: /rarebit [status|recall|fork|config|auto-title|title|summarize]",
   );
   assert.equal(
     rarebitCommandUsage("config"),
@@ -44,6 +44,8 @@ test("parser accepts exactly the command grammar", () => {
     subcommand: "status",
     arguments: [],
   });
+  assert.equal(parseRarebitCommand("fork").ok, true);
+  assert.equal(parseRarebitCommand("fork --max-token-length 64000").ok, true);
   assert.equal(parseRarebitCommand("config").ok, true);
   assert.equal(parseRarebitCommand("config max_rarebit_ratio 0.4").ok, true);
   assert.equal(parseRarebitCommand("config min_total_length 80000").ok, true);
@@ -93,6 +95,7 @@ test("autocomplete covers subcommands and discrete nested arguments", () => {
   assert.deepEqual(values(""), [
     "status",
     "recall",
+    "fork",
     "config",
     "auto-title",
     "title",

package/test/rarebit-core.test.mjs

@@ -197,7 +197,7 @@ test("Summary normalization accepts explicit uncertainty and conflicting evidenc
   }
 });
 
-test("Pi Summary model calls forward the stable Session cache identity", async () => {
+test("Pi Summary fallback model calls forward the stable Session cache identity", async () => {
   let receivedOptions;
   const client = await createPiRarebitModelClient(
     {
@@ -220,6 +220,40 @@ test("Pi Summary model calls forward the stable Session cache identity", async (
   assert.equal(receivedOptions.sessionId, "session-cache-1");
 });
 
+test("Pi Summary uses the current model registry and preserves null header deletions", async () => {
+  let received;
+  const client = await createPiRarebitModelClient(
+    {
+      modelRegistry: {
+        find: () => ({ provider: "runtime", id: "registered-model" }),
+        getApiKeyAndHeaders: async () => ({
+          ok: true,
+          apiKey: "test-key",
+          headers: { "x-retained": "value", "x-delete": null },
+        }),
+        complete: async function (model, context, options) {
+          assert.equal(typeof this.find, "function");
+          received = { model, context, options };
+          return { text: "ok" };
+        },
+      },
+    },
+    {
+      model: { provider: "runtime", id: "registered-model" },
+      piAi: { complete: async () => { throw new Error("fallback used"); } },
+    },
+  );
+  await client.complete({ prompt: "prompt", cacheSessionId: "session-cache-2" });
+  assert.equal(received.model.provider, "runtime");
+  assert.equal(received.model.id, "registered-model");
+  assert.equal(received.context.messages[0].content[0].text, "prompt");
+  assert.deepEqual(received.options.headers, {
+    "x-retained": "value",
+    "x-delete": null,
+  });
+  assert.equal(received.options.sessionId, "session-cache-2");
+});
+
 test("job identity varies with an operation's semantic inputs, not raw source path", () => {
   const selection = selectRarebits([
     entry("u", { role: "user", content: "goal" }),

package/test/rarebit-fork.test.mjs

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { spawnSync } from "node:child_process";
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+import {
+  buildRarebitForkPlan,
+  checkRarebitForkHeadroom,
+  createRarebitForkEntries,
+} from "../src/rarebit-fork.mjs";
+import {
+  getImportedRarebitEntryIds,
+  getRarebitForkSeedEntryIds,
+} from "../src/rarebit-fork-lineage.mjs";
+import { projectRarebitSessionActivity } from "../src/rarebit-activity.mjs";
+import registerPiRarebit from "../src/extension.mjs";
+
+const entry = (id, message, order) => ({
+  type: "message", id, parentId: order ? `e${order - 1}` : null,
+  timestamp: `2026-09-21T00:00:0${order}.000Z`, message,
+});
+
+test("fork keeps a maximal newest suffix under aggregate chars/4 and preserves outcomes", () => {
+  const branch = [
+    entry("e0", { role: "user", content: "old" }, 0),
+    entry("e1", { role: "assistant", stopReason: "toolUse", content: "middle" }, 1),
+    entry("e2", { role: "assistant", stopReason: "stop", content: "newest" }, 2),
+  ];
+  const plan = buildRarebitForkPlan({
+    header: { id: "source", cwd: "/source" }, sessionFile: "/source/s.jsonl",
+    cwd: "/source", branch, targetCwd: "/target", maxTokenLength: 2,
+    targetModel: { provider: "test", id: "target", contextWindow: 100_000 },
+    reserveTokens: 16_384,
+  });
+  assert.deepEqual(plan.selected.map((item) => item.sourceEntryId), ["e2"]);
+  assert.equal(plan.importedTokens, 2);
+  const built = createRarebitForkEntries(plan, { sessionId: "forked" });
+  const imported = built.entries.filter((item) => item.rarebitFork?.kind === "import");
+  assert.equal(imported[0].message.stopReason, "stop");
+  assert.equal(imported[0].message.provider, "rarebit-import");
+  assert.equal(imported[0].timestamp, plan.forkCreatedAt);
+  const modelChange = built.entries.at(-1);
+  assert.equal(modelChange.type, "model_change");
+  assert.deepEqual({ provider: modelChange.provider, id: modelChange.modelId }, { provider: "test", id: "target" });
+  assert.deepEqual(getImportedRarebitEntryIds(built.entries), new Set([built.entries[0].id, imported[0].id]));
+  assert.deepEqual(getRarebitForkSeedEntryIds(built.entries), new Set([built.entries[0].id]));
+});
+
+test("fork marker stays machine-only in Pi context and activity excludes seeded entries", () => {
+  const branch = [entry("e0", { role: "user", content: "source" }, 0)];
+  const plan = buildRarebitForkPlan({
+    header: { id: "source", cwd: "/source" }, sessionFile: "/source/s.jsonl", cwd: "/source",
+    branch, targetCwd: "/target", targetModel: { provider: "test", id: "target", contextWindow: 100_000 },
+  });
+  const built = createRarebitForkEntries(plan, { sessionId: "forked" });
+  const seeded = built.entries[0];
+  assert.equal(sessionEntryToContextMessages(seeded)[0].role, "user");
+  assert.equal("rarebitFork" in sessionEntryToContextMessages(seeded)[0], false);
+  const activity = projectRarebitSessionActivity({ ...({ occurrences: [{ sourceEntryId: seeded.id, role: "user", outcome: "user", timestamp: seeded.timestamp }] }), entries: built.entries });
+  assert.equal(activity.latestUser, null);
+});
+
+test("repeat forks preserve marker ancestry and apostrophe-safe PiQ recovery", () => {
+  const sourceBranch = [entry("e0", { role: "user", content: "source" }, 0)];
+  const sourcePlan = buildRarebitForkPlan({ header: { id: "source", cwd: "/source" }, sessionFile: "/tmp/a'b.jsonl", cwd: "/source", branch: sourceBranch, targetCwd: "/target", targetModel: { provider: "test", id: "target", contextWindow: 100_000 } });
+  const first = createRarebitForkEntries(sourcePlan, { sessionId: "first" });
+  const secondPlan = buildRarebitForkPlan({ header: first.header, sessionFile: "/target/first.jsonl", cwd: "/target", branch: first.entries.slice(0, -2), targetCwd: "/target", targetModel: { provider: "test", id: "target", contextWindow: 100_000 } });
+  assert.equal(secondPlan.selected.length, 1);
+  const second = createRarebitForkEntries(secondPlan, { sessionId: "second" });
+  assert.equal(second.manifest.mappings[0].ancestry.length, 2);
+  assert.equal(second.manifest.mappings[0].ancestry[0].sessionId, "source");
+  assert.equal(second.manifest.mappings[0].ancestry[1].sessionId, "first");
+  const recovery = first.entries[0].message.content.split("\n").find((line) => line.startsWith("Recover source"));
+  const command = recovery.slice(recovery.indexOf(": ") + 2).replace(/^piq entries/, "set --");
+  const shell = spawnSync("sh", ["-c", `${command}; printf '%s' \"$2\"`], { encoding: "utf8" });
+  assert.equal(shell.status, 0);
+  assert.equal(shell.stdout, "/tmp/a'b.jsonl");
+});
+
+test("tool schema overhead can refuse when prose and prompt alone fit", () => {
+  assert.doesNotThrow(() => checkRarebitForkHeadroom({ seedText: "x", contextWindow: 100, reserveTokens: 90, promptOverheadTokens: 8, toolOverheadTokens: 0 }));
+  assert.throws(() => checkRarebitForkHeadroom({ seedText: "x", contextWindow: 100, reserveTokens: 90, promptOverheadTokens: 8, toolOverheadTokens: 3 }), /headroom|reserve/i);
+});
+
+test("slash fork counts active Pi tool schemas before writing or switching", async () => {
+  const commands = new Map();
+  let switched = false;
+  const notifications = [];
+  const pi = {
+    on: () => {},
+    registerCommand: (name, command) => commands.set(name, command),
+    getActiveTools: () => ["large_tool"],
+    getAllTools: () => [{ name: "large_tool", description: "tool", parameters: { type: "object", properties: { payload: { type: "string", description: "x".repeat(2_000) } } } }],
+  };
+  registerPiRarebit(pi, { settingsLoader: async () => ({ reserveTokens: 0 }) });
+  const branch = [entry("source-entry", { role: "user", content: "source" }, 0)];
+  const ctx = {
+    hasUI: true, cwd: "/tmp", model: { provider: "test", id: "target", contextWindow: 100 },
+    getSystemPrompt: () => "", getActiveTools: () => ["large_tool"],
+    waitForIdle: async () => {}, isIdle: () => true,
+    ui: { notify: (message, level) => notifications.push({ message, level }) },
+    switchSession: async () => { switched = true; return { cancelled: false }; },
+    sessionManager: {
+      getSessionFile: () => "/tmp/source.jsonl", getHeader: () => ({ id: "source" }), getBranch: () => branch,
+      getLeafId: () => "source-entry", getSessionDir: () => "/tmp",
+    },
+  };
+  await commands.get("rarebit").handler("fork", ctx);
+  assert.equal(switched, false);
+  ctx.model = null;
+  await commands.get("rarebit").handler("fork", ctx);
+  assert.equal(switched, false);
+  assert.match(notifications.at(-1).message, /destination model\/context window is unavailable/);
+});
+
+test("headroom refuses before a destination can be switched", () => {
+  assert.throws(() => buildRarebitForkPlan({
+    header: { id: "source" }, sessionFile: "/source/s.jsonl", branch: [entry("e0", { role: "user", content: "x" }, 0)],
+    maxTokenLength: 10, targetModel: { provider: "test", id: "tiny", contextWindow: 10 }, reserveTokens: 9,
+  }), /headroom|reserve/i);
+});