[Init] Initial commit - NetMesh terminal manager

components/ai/scopedHistorySessions.test.ts

@@ -0,0 +1,224 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { AISession } from "../../infrastructure/ai/types.ts";
+import {
+  _getScopedHistoryCacheSizeForTests,
+  getScopedHistorySessions,
+} from "./scopedHistorySessions.ts";
+
+function createSession(
+  id: string,
+  scope: AISession["scope"],
+  updatedAt: number,
+): AISession {
+  return {
+    id,
+    title: id,
+    agentId: "catty",
+    scope,
+    messages: [],
+    createdAt: updatedAt,
+    updatedAt,
+  };
+}
+
+test("workspace history remains visible after the original workspace target is gone", () => {
+  const staleWorkspaceSession = createSession(
+    "workspace-stale",
+    { type: "workspace", targetId: "workspace-before-restart" },
+    2,
+  );
+
+  const sessions = [
+    staleWorkspaceSession,
+    createSession("terminal-session", { type: "terminal", targetId: "terminal-1" }, 3),
+  ];
+
+  assert.deepEqual(
+    getScopedHistorySessions(
+      sessions,
+      "workspace",
+      "workspace-after-restart",
+      undefined,
+      new Set(),
+    ),
+    [staleWorkspaceSession],
+  );
+});
+
+test("workspace history includes member-terminal chats and ranks them above stale workspaces", () => {
+  const memberTerminalSession = createSession(
+    "terminal-a-chat",
+    { type: "terminal", targetId: "terminal-a" },
+    1,
+  );
+  const staleWorkspaceSession = createSession(
+    "workspace-stale",
+    { type: "workspace", targetId: "workspace-before-restart" },
+    99,
+  );
+
+  assert.deepEqual(
+    getScopedHistorySessions(
+      [staleWorkspaceSession, memberTerminalSession],
+      "workspace",
+      "workspace-merged",
+      ["host-a"],
+      new Set(),
+      new Set(["terminal-a", "terminal-b"]),
+    ).map((session) => session.id),
+    ["terminal-a-chat", "workspace-stale"],
+  );
+});
+
+test("terminal history without host ids remains visible after the original terminal target is gone", () => {
+  const staleLocalSession = createSession(
+    "terminal-local-stale",
+    { type: "terminal", targetId: "terminal-before-restart" },
+    2,
+  );
+
+  assert.deepEqual(
+    getScopedHistorySessions(
+      [staleLocalSession],
+      "terminal",
+      "terminal-after-restart",
+      undefined,
+      new Set(),
+    ),
+    [staleLocalSession],
+  );
+});
+
+test("scoped history orders exact, host-matched, then older same-scope sessions", () => {
+  const staleSameScopeSession = createSession(
+    "same-scope-stale",
+    { type: "terminal", targetId: "terminal-closed" },
+    100,
+  );
+  const hostMatchedSession = createSession(
+    "host-match",
+    { type: "terminal", targetId: "terminal-other", hostIds: ["host-a"] },
+    2,
+  );
+  const exactSession = createSession(
+    "exact",
+    { type: "terminal", targetId: "terminal-current" },
+    1,
+  );
+
+  assert.deepEqual(
+    getScopedHistorySessions(
+      [staleSameScopeSession, hostMatchedSession, exactSession],
+      "terminal",
+      "terminal-current",
+      ["host-a"],
+      new Set(),
+    ).map((session) => session.id),
+    ["exact", "host-match", "same-scope-stale"],
+  );
+});
+
+test("same-scope fallback excludes sessions already displayed by another terminal", () => {
+  const displayedElsewhere = createSession(
+    "displayed-elsewhere",
+    { type: "terminal", targetId: "terminal-before-restart" },
+    2,
+  );
+
+  assert.deepEqual(
+    getScopedHistorySessions(
+      [displayedElsewhere],
+      "terminal",
+      "terminal-after-restart",
+      undefined,
+      new Set(["displayed-elsewhere"]),
+    ),
+    [],
+  );
+});
+
+test("workspace cache ignores unrelated active terminal churn", () => {
+  const sessions = [createSession("workspace", { type: "workspace", targetId: "workspace-1" }, 1)];
+  const first = getScopedHistorySessions(
+    sessions,
+    "workspace",
+    "workspace-1",
+    undefined,
+    new Set(["terminal-0"]),
+  );
+  for (let index = 1; index < 1_000; index += 1) {
+    assert.equal(getScopedHistorySessions(
+      sessions,
+      "workspace",
+      "workspace-1",
+      undefined,
+      new Set([`terminal-${index}`]),
+    ), first);
+  }
+  assert.equal(_getScopedHistoryCacheSizeForTests(sessions), 1);
+});
+
+test("terminal scoped history cache has a hard LRU bound", () => {
+  const sessions = [createSession("terminal", { type: "terminal", targetId: "terminal-current" }, 1)];
+  for (let index = 0; index < 1_000; index += 1) {
+    getScopedHistorySessions(
+      sessions,
+      "terminal",
+      "terminal-current",
+      undefined,
+      new Set([`other-session-${index}`]),
+    );
+  }
+  assert.ok(_getScopedHistoryCacheSizeForTests(sessions) <= 64);
+});
+
+test("workspace history retains chats resumed by members from older terminals", () => {
+  const resumed = createSession("resumed", {
+    type: "terminal", targetId: "closed-terminal", hostIds: ["host-a"],
+  }, 1);
+  const unrelated = createSession("unrelated", {
+    type: "terminal", targetId: "another-closed-terminal", hostIds: ["host-a"],
+  }, 2);
+  const staleWorkspace = createSession("stale-workspace", {
+    type: "workspace", targetId: "old-workspace",
+  }, 99);
+  const sessions = [staleWorkspace, unrelated, resumed];
+  const members = new Set(["terminal-a", "terminal-b"]);
+  const selected = {
+    "terminal:terminal-a": "resumed",
+    "terminal:terminal-outside": "unrelated",
+  };
+
+  assert.ok(getScopedHistorySessions(
+    sessions, "terminal", "terminal-a", ["host-a"], new Set(["unrelated"]),
+  ).includes(resumed));
+  assert.deepEqual(getScopedHistorySessions(
+    sessions, "workspace", "merged", ["host-a"], new Set(Object.values(selected)),
+    members, selected,
+  ), [resumed, staleWorkspace]);
+  // Returning to A makes the same stored conversation available again.
+  assert.ok(getScopedHistorySessions(
+    sessions, "terminal", "terminal-a", ["host-a"], new Set(["unrelated"]),
+  ).includes(resumed));
+  assert.equal(resumed.scope.targetId, "closed-terminal");
+});
+
+test("workspace history cache tracks member selections but ignores unrelated selections", () => {
+  const sessions = [createSession("resumed", { type: "terminal", targetId: "closed" }, 1)];
+  const members = new Set(["terminal-a"]);
+  const history = (selected: Record<string, string | null>) => getScopedHistorySessions(
+    sessions, "workspace", "merged", undefined, new Set(), members, selected,
+  );
+  const empty = history({});
+  assert.deepEqual(empty, []);
+  const inherited = history({ "terminal:terminal-a": "resumed" });
+  assert.deepEqual(inherited, sessions);
+  assert.equal(history({
+    "terminal:terminal-a": "resumed", "terminal:outside": "other",
+  }), inherited);
+  assert.equal(history({ "terminal:terminal-a": null }), empty);
+  assert.equal(history({ "workspace:unrelated": "resumed" }), empty);
+  assert.equal(_getScopedHistoryCacheSizeForTests(sessions), 2);
+});