gentle-pi 3.6.0 → 4.0.0

package/tests/history-drain-hidden.test.ts

@@ -0,0 +1,110 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  drainGlobal,
+  drainProject,
+  globalSeedPath,
+  projectHash,
+  type DrainResult,
+} from "../extensions/history/store.ts";
+
+// Portable project identity: a never-existing literal. projectHash falls
+// back to hashing the raw string when realpath fails, so the identity is
+// deterministic on every machine (no machine-specific absolute paths).
+
+const CWD = "/pi-history-test/drain-hidden-project";
+
+function write(file: string, texts: string[], ts = 100): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(
+    file,
+    `${texts.map((t) => JSON.stringify({ v: 1, text: t, ts })).join("\n")}\n`,
+    "utf8",
+  );
+}
+
+// Unwrap the ok shape. Drains FAIL CLOSED: the blocked variant carries no
+// prompts field at all (asserted in the blocked test below).
+function okPrompts(result: DrainResult): string[] {
+  assert.equal(result.status, "ok");
+  if (result.status !== "ok") throw new Error("unreachable");
+  return result.prompts;
+}
+
+test("drains skip tombstoned prompts in seeds and session files", () => {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), "hid-"));
+  const root = path.join(base, "h");
+  const stateDir = path.join(base, "state");
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(stateDir, "hidden.json"),
+    JSON.stringify(["deleted from seed", "deleted from session"]),
+    "utf8",
+  );
+  const dir = path.join(root, "projects", projectHash(CWD));
+  write(path.join(dir, "seed.jsonl"), ["keep", "deleted from seed"], 100);
+  write(path.join(dir, "s1.jsonl"), ["also keep", "deleted from session"], 200);
+  write(globalSeedPath(root), ["deleted from seed", "legacy keep"], 50);
+
+  assert.deepEqual(okPrompts(drainProject(root, CWD, 1000, stateDir)), [
+    "also keep",
+    "keep",
+  ]);
+  assert.deepEqual(okPrompts(drainGlobal(root, 1000, stateDir)), [
+    "also keep",
+    "keep",
+    "legacy keep",
+  ]);
+  // Without a stateDir the filter is off (raw drain semantics).
+  assert.equal(
+    okPrompts(drainProject(root, CWD)).includes("deleted from seed"),
+    true,
+  );
+});
+
+// Fail-closed seam: an untrusted hidden.json BLOCKS both drains with the
+// recovery message and no prompts field; a stateDir whose hidden.json is
+// MISSING stays the safe empty-tombstones case (the full expected prompts).
+test("corrupt hidden.json blocks both drains with no prompts field; a missing file drains normally", () => {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), "hid-blocked-"));
+  const root = path.join(base, "h");
+  const stateDir = path.join(base, "state");
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(stateDir, "hidden.json"),
+    "{corrupt bytes",
+    "utf8",
+  );
+  const dir = path.join(root, "projects", projectHash(CWD));
+  write(path.join(dir, "seed.jsonl"), ["secret prompt", "keeper"], 100);
+
+  for (const result of [
+    drainProject(root, CWD, 1000, stateDir),
+    drainGlobal(root, 1000, stateDir),
+  ]) {
+    assert.equal(result.status, "blocked");
+    if (result.status !== "blocked") throw new Error("unreachable");
+    assert.ok(result.message.includes("hidden.json"));
+    // The blocked shape carries no prompts to render.
+    assert.equal("prompts" in result, false);
+  }
+
+  // Missing file: safe empty tombstones — the full drain comes back.
+  const missingBase = fs.mkdtempSync(path.join(os.tmpdir(), "hid-missing-"));
+  const missingRoot = path.join(missingBase, "h");
+  const missingState = path.join(missingBase, "state");
+  fs.mkdirSync(missingState, { recursive: true });
+  const missingDir = path.join(missingRoot, "projects", projectHash(CWD));
+  write(path.join(missingDir, "seed.jsonl"), ["kept", "shown"], 100);
+  assert.deepEqual(
+    okPrompts(drainProject(missingRoot, CWD, 1000, missingState)),
+    ["shown", "kept"],
+  );
+  assert.deepEqual(okPrompts(drainGlobal(missingRoot, 1000, missingState)), [
+    "shown",
+    "kept",
+  ]);
+});

package/tests/history-drain-order.test.ts

@@ -0,0 +1,98 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  drainGlobal,
+  drainProject,
+  globalSeedPath,
+  projectHash,
+  type DrainResult,
+} from "../extensions/history/store.ts";
+
+// Portable project identity: a never-existing literal. projectHash falls
+// back to hashing the raw string when realpath fails, so the identity is
+// deterministic on every machine (no machine-specific absolute paths).
+
+const CWD = "/pi-history-test/drain-order-project";
+
+function writeTs(file: string, texts: string[], ts: number): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(
+    file,
+    `${texts.map((t) => JSON.stringify({ v: 1, text: t, ts })).join("\n")}\n`,
+    "utf8",
+  );
+}
+
+// Mechanical unwrap of the ok shape (drains can also return blocked).
+function okPrompts(result: DrainResult): string[] {
+  assert.equal(result.status, "ok");
+  if (result.status !== "ok") throw new Error("unreachable");
+  return result.prompts;
+}
+
+test("atomic rewrite (delete) does not reshuffle the drain order", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ord-"));
+  const dir = path.join(root, "projects", projectHash(CWD));
+  writeTs(path.join(dir, "old.jsonl"), ["a-old"], 100);
+  writeTs(path.join(dir, "new.jsonl"), ["z-new"], 200);
+  assert.deepEqual(okPrompts(drainProject(root, CWD)), ["z-new", "a-old"]);
+  // Slice 5 ports deleteFromProject; its observable effect on the drain is
+  // simulated directly here: an atomic rewrite of the affected file that
+  // empties it — the mtime jumps to NOW, and the drain order must not move.
+  fs.writeFileSync(path.join(dir, "old.jsonl"), "", "utf8");
+  fs.utimesSync(path.join(dir, "old.jsonl"), new Date(), new Date());
+  assert.deepEqual(okPrompts(drainProject(root, CWD)), ["z-new"]);
+  // Re-add with an OLD ts via direct write: still ordered by ts, not mtime.
+  writeTs(path.join(dir, "old2.jsonl"), ["b-old"], 150);
+  fs.utimesSync(
+    path.join(dir, "old2.jsonl"),
+    new Date(Date.now() + 99999),
+    new Date(Date.now() + 99999),
+  );
+  assert.deepEqual(okPrompts(drainProject(root, CWD)), ["z-new", "b-old"]);
+});
+
+test("global drain puts the legacy seed last regardless of its fresh mtime", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "seed-"));
+  const dir = path.join(root, "projects", projectHash(CWD));
+  writeTs(path.join(dir, "s.jsonl"), ["fresh"], 200);
+  const seed = globalSeedPath(root);
+  writeTs(seed, ["legacy-1", "legacy-2"], 10);
+  fs.utimesSync(seed, new Date(Date.now() + 5000), new Date(Date.now() + 5000));
+  assert.deepEqual(okPrompts(drainGlobal(root)), [
+    "fresh",
+    "legacy-2",
+    "legacy-1",
+  ]);
+});
+
+test(
+  "an unreadable store file is skipped; the rest drain in the expected order",
+  { skip: process.getuid?.() === 0 },
+  () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "ord-sealed-"));
+    const dir = path.join(root, "projects", projectHash(CWD));
+    writeTs(path.join(dir, "old.jsonl"), ["a-old"], 100);
+    const sealed = path.join(dir, "sealed.jsonl");
+    writeTs(sealed, ["sealed-never"], 150);
+    writeTs(path.join(dir, "new.jsonl"), ["z-new"], 200);
+    // The sealed file's fresh mtime would sort it FIRST if it were readable —
+    // its absence from the drain is caused by the unreadable skip alone.
+    fs.utimesSync(
+      sealed,
+      new Date(Date.now() + 99999),
+      new Date(Date.now() + 99999),
+    );
+    fs.chmodSync(sealed, 0o000);
+    try {
+      // An unreadable file reads as zero entries and drops out of the drain;
+      // the readable files keep their ts order. No throw.
+      assert.deepEqual(okPrompts(drainProject(root, CWD)), ["z-new", "a-old"]);
+    } finally {
+      fs.chmodSync(sealed, 0o644); // restore before cleanup
+    }
+  },
+);

package/tests/history-expanded-globals.test.ts

@@ -0,0 +1,62 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  type PiHistoryGlobals,
+  withExpandedHistoryGlobals,
+} from "../extensions/history/selector-helpers.ts";
+
+// withExpandedHistoryGlobals contract: optional hooks invoked via `?.` —
+// expand exactly once BEFORE the run starts, trim exactly once in the
+// finally (success and rejection alike), and the run's resolution passes
+// through untouched. Fixtures track call order in one array so the
+// before/after ordering and the call counts are pinned together.
+
+function trackingGlobals(): { globals: PiHistoryGlobals; events: string[] } {
+  const events: string[] = [];
+  return {
+    events,
+    globals: {
+      __piHistoryExpand: () => {
+        events.push("expand");
+      },
+      __piHistoryTrim: () => {
+        events.push("trim");
+      },
+    },
+  };
+}
+
+test("expand runs once before the run; trim once after; the result passes through", async () => {
+  const { globals, events } = trackingGlobals();
+  let ran = 0;
+  const value = await withExpandedHistoryGlobals(globals, async () => {
+    // By the time the body executes, expand already ran — exactly once.
+    ran += 1;
+    assert.deepEqual(events, ["expand"]);
+    return 42;
+  });
+  assert.equal(value, 42);
+  assert.equal(ran, 1);
+  assert.deepEqual(events, ["expand", "trim"]);
+});
+
+test("a rejected run still trims (finally) and the rejection propagates unchanged", async () => {
+  const { globals, events } = trackingGlobals();
+  const boom = new Error("boom");
+  let caught: unknown;
+  try {
+    await withExpandedHistoryGlobals(globals, async () => {
+      throw boom;
+    });
+  } catch (error) {
+    caught = error;
+  }
+  assert.equal(caught, boom);
+  assert.deepEqual(events, ["expand", "trim"]);
+});
+
+test("absent hooks are tolerated: the run executes with no throw", async () => {
+  const empty: PiHistoryGlobals = {};
+  const value = await withExpandedHistoryGlobals(empty, async () => "ok");
+  assert.equal(value, "ok");
+});