@hassangameryt/freeflow 0.4.0 → 0.6.0

package/pi-extension/tests/context-virtualization/projector.test.js

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { archiveContent, fullContent, projectToolResultMessage } from "../../dist/context-virtualization/projector.js";
+import { CONTEXT_REF_PREFIX, contextRefForEntry } from "../../dist/freeflow-context/types.js";
+import { replayProjectionEntries } from "../../dist/context-virtualization/state.js";
+
+const source = {
+  sessionId: "session-1",
+  entryId: "abcd1234",
+  toolCallId: "call-1",
+  toolName: "read",
+};
+
+const message = {
+  role: "toolResult",
+  toolCallId: "call-1",
+  toolName: "read",
+  content: [
+    { type: "text", text: "line one" },
+    { type: "image", data: "encoded", mimeType: "image/png" },
+  ],
+  isError: false,
+  timestamp: 1,
+};
+
+test("full projection preserves the tool result and adds one projection-only reference", () => {
+  const original = structuredClone(message);
+  const projected = projectToolResultMessage(message, source, { mode: "full" });
+
+  assert.deepEqual(message, original);
+  assert.equal(projected.role, "toolResult");
+  assert.equal(projected.toolCallId, message.toolCallId);
+  assert.deepEqual(projected.content.slice(0, -1), message.content);
+  assert.deepEqual(projected.content.at(-1), {
+    type: "text",
+    text: `[context-ref: ${CONTEXT_REF_PREFIX}abcd1234]`,
+  });
+});
+
+test("archive projection removes raw blocks and retains optional model-authored meaning", () => {
+  const projected = projectToolResultMessage(message, source, {
+    mode: "archived",
+    retained: "The file contains the failing authentication path.",
+  });
+
+  assert.deepEqual(projected.content, [
+    {
+      type: "text",
+      text: archiveContent(source, "The file contains the failing authentication path."),
+    },
+  ]);
+  assert.equal(projected.toolName, "read");
+  assert.equal(projected.isError, false);
+});
+
+test("projection helpers produce stable current-session references", () => {
+  assert.equal(contextRefForEntry(source.entryId), "ctx:abcd1234");
+  assert.equal(fullContent(source).at(-1).text, "[context-ref: ctx:abcd1234]");
+});
+
+test("projection journal replay applies resets and latest branch-local changes", () => {
+  const state = replayProjectionEntries(
+    [
+      {
+        type: "custom",
+        customType: "freeflow-context-projection",
+        data: {
+          version: 1,
+          actor: "model",
+          changes: [
+            {
+              source,
+              projection: { mode: "archived", retained: "first" },
+            },
+          ],
+        },
+      },
+      {
+        type: "custom",
+        customType: "freeflow-context-projection",
+        data: {
+          version: 1,
+          actor: "user",
+          reset: "all",
+        },
+      },
+      {
+        type: "custom",
+        customType: "freeflow-context-projection",
+        data: {
+          version: 1,
+          actor: "model",
+          changes: [
+            {
+              source,
+              projection: { mode: "archived" },
+            },
+          ],
+        },
+      },
+    ],
+    source.sessionId,
+  );
+
+  assert.deepEqual(state.get(source.entryId), {
+    mode: "archived",
+    source,
+  });
+});

package/pi-extension/tests/context-virtualization/runtime.test.js

@@ -0,0 +1,216 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { ContextSourceResolver } from "../../dist/freeflow-context/resolver.js";
+import { ContextVirtualizationRuntime } from "../../dist/context-virtualization/runtime.js";
+import { CONTEXT_PROJECTION_ENTRY } from "../../dist/context-virtualization/types.js";
+import { contextRefForEntry } from "../../dist/freeflow-context/types.js";
+
+function createFixture() {
+  const entries = [
+    {
+      type: "message",
+      id: "user-1",
+      parentId: null,
+      message: { role: "user", content: "Inspect the file." },
+    },
+    {
+      type: "message",
+      id: "tool-1",
+      parentId: "user-1",
+      message: {
+        role: "toolResult",
+        toolCallId: "call-1",
+        toolName: "read",
+        content: [{ type: "text", text: "secret raw output" }],
+        isError: false,
+      },
+    },
+  ];
+  let nextId = 1;
+  const ctx = {
+    cwd: "/repo",
+    sessionManager: {
+      getSessionId: () => "session-1",
+      getLeafId: () => entries.at(-1)?.id ?? null,
+      getBranch: () => entries,
+      buildContextEntries: () => entries.filter((entry) => entry.type === "message"),
+    },
+  };
+  const pi = {
+    appendEntryDurable(customType, data) {
+      entries.push({
+        type: "custom",
+        id: `journal-${nextId++}`,
+        parentId: entries.at(-1)?.id ?? null,
+        customType,
+        data,
+      });
+    },
+  };
+  return { entries, ctx, pi, runtime: new ContextVirtualizationRuntime(pi, ctx) };
+}
+
+function toolMessage(text = "secret raw output") {
+  return {
+    role: "toolResult",
+    toolCallId: "call-1",
+    toolName: "read",
+    content: [{ type: "text", text }],
+    isError: false,
+  };
+}
+
+test("generic resolver resolves current-session source identity without changing V1 tool-result validation", () => {
+  const { ctx } = createFixture();
+  const resolver = new ContextSourceResolver(ctx);
+  assert.equal(resolver.resolveCurrent("ctx:tool-1").kind, "toolResult");
+  assert.equal(resolver.resolveCurrent("ctx:user-1").kind, "user");
+  assert.equal(resolver.resolveCurrent("ctx:missing"), undefined);
+});
+
+test("runtime refreshes its resolver when lifecycle recovery switches contexts", async () => {
+  const first = createFixture();
+  const second = createFixture();
+  second.ctx.sessionManager.getSessionId = () => "session-2";
+  second.entries[1].id = "tool-2";
+  second.entries[1].message.toolCallId = "call-2";
+
+  await first.runtime.recover(second.ctx);
+  const projected = await first.runtime.project(
+    [
+      {
+        role: "toolResult",
+        toolCallId: "call-2",
+        toolName: "read",
+        content: [{ type: "text", text: "second context" }],
+        isError: false,
+      },
+    ],
+    true,
+  );
+  assert.match(projected.messages[0].content.at(-1).text, /ctx:tool-2/);
+});
+
+test("projection recovery failure fails open for Conversation History visibility", async () => {
+  const { runtime, ctx } = createFixture();
+  await runtime.project([toolMessage()], true);
+  await runtime.archive([{ ref: contextRefForEntry("tool-1") }]);
+
+  ctx.sessionManager.getBranch = () => {
+    throw new Error("projection recovery failed");
+  };
+  assert.equal(await runtime.recover(ctx), false);
+  assert.equal(runtime.isSourceFullyProjected("tool-1"), true);
+});
+
+test("runtime projects full results, archives them, and restores them without mutating source content", async () => {
+  const { entries, runtime } = createFixture();
+  const original = structuredClone(entries[1].message);
+
+  const full = await runtime.project([toolMessage()], true);
+  assert.equal(full.changed, true);
+  assert.match(full.messages[0].content.at(-1).text, /ctx:tool-1/);
+
+  const archived = await runtime.archive([
+    { ref: contextRefForEntry("tool-1"), retained: "The file contains the failing path." },
+  ]);
+  assert.equal(archived.status, "ok");
+  assert.equal(entries[2].customType, CONTEXT_PROJECTION_ENTRY);
+
+  const afterArchive = await runtime.project([toolMessage()], true);
+  assert.deepEqual(afterArchive.messages[0].content, [
+    {
+      type: "text",
+      text: "[context archived: ctx:tool-1]\n\n<retained-context>\nThe file contains the failing path.\n</retained-context>",
+    },
+  ]);
+  assert.deepEqual(entries[1].message, original);
+
+  const restored = await runtime.restore([contextRefForEntry("tool-1")]);
+  assert.equal(restored.status, "ok");
+  const afterRestore = await runtime.project([toolMessage()], true);
+  assert.match(afterRestore.messages[0].content.at(-1).text, /ctx:tool-1/);
+  assert.deepEqual(afterRestore.messages[0].content[0], original.content[0]);
+});
+
+test("archive batches validate atomically and reject unseen references", async () => {
+  const { runtime } = createFixture();
+  await runtime.project([toolMessage()], true);
+
+  const result = await runtime.archive([{ ref: contextRefForEntry("tool-1") }, { ref: contextRefForEntry("missing") }]);
+  assert.equal(result.status, "rejected");
+  assert.match(result.message, /target_not_in_consumed_context/);
+
+  const next = await runtime.project([toolMessage()], true);
+  assert.match(next.messages[0].content.at(-1).text, /ctx:tool-1/);
+});
+
+test("archive rejects duplicate normalized references atomically", async () => {
+  const { runtime } = createFixture();
+  await runtime.project([toolMessage()], true);
+
+  const result = await runtime.archive([
+    { ref: contextRefForEntry("tool-1") },
+    { ref: `${contextRefForEntry("tool-1")} ` },
+  ]);
+  assert.equal(result.status, "rejected");
+  assert.match(result.message, /duplicate_reference:ctx:tool-1/);
+
+  const next = await runtime.project([toolMessage()], true);
+  assert.match(next.messages[0].content.at(-1).text, /ctx:tool-1/);
+  assert.doesNotMatch(next.messages[0].content[0].text, /context archived/);
+});
+
+test("restore rejects duplicate normalized references atomically", async () => {
+  const { runtime } = createFixture();
+  await runtime.project([toolMessage()], true);
+  assert.equal((await runtime.archive([{ ref: contextRefForEntry("tool-1") }])).status, "ok");
+
+  const result = await runtime.restore([contextRefForEntry("tool-1"), `${contextRefForEntry("tool-1")} `]);
+  assert.equal(result.status, "rejected");
+  assert.match(result.message, /duplicate_reference:ctx:tool-1/);
+
+  const next = await runtime.project([toolMessage()], true);
+  assert.match(next.messages[0].content[0].text, /context archived: ctx:tool-1/);
+});
+
+test("restore after compaction records full state but reports history-only availability", async () => {
+  const { ctx, runtime } = createFixture();
+  await runtime.project([toolMessage()], true);
+  assert.equal((await runtime.archive([{ ref: contextRefForEntry("tool-1") }])).status, "ok");
+
+  ctx.sessionManager.buildContextEntries = () => [
+    {
+      type: "message",
+      id: "summary-1",
+      parentId: "tool-1",
+      message: { role: "user", content: "The earlier context was compacted." },
+    },
+  ];
+  await runtime.recover(ctx);
+  const restored = await runtime.restore([contextRefForEntry("tool-1")], "user");
+  assert.equal(restored.status, "ok");
+  assert.equal(restored.availability[contextRefForEntry("tool-1")], "history-only");
+});
+
+test("mutation persistence failure returns an error without publishing projection state", async () => {
+  const { pi, runtime } = createFixture();
+  await runtime.project([toolMessage()], true);
+  pi.appendEntryDurable = () => {
+    throw new Error("disk unavailable");
+  };
+
+  const result = await runtime.archive([{ ref: contextRefForEntry("tool-1") }]);
+  assert.equal(result.status, "rejected");
+  assert.match(result.message, /persistence_failed:disk unavailable/);
+  const next = await runtime.project([toolMessage()], true);
+  assert.match(next.messages[0].content.at(-1).text, /ctx:tool-1/);
+});
+
+test("disabled projection bypasses stored state and adds no marker", async () => {
+  const { runtime } = createFixture();
+  const result = await runtime.project([toolMessage()], false);
+  assert.equal(result.changed, false);
+  assert.deepEqual(result.messages[0].content, [{ type: "text", text: "secret raw output" }]);
+});

package/pi-extension/tests/conversation-history/runtime.test.js

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { ConversationHistoryRuntime } from "../../dist/conversation-history/runtime.js";
+
+function sourceEntry() {
+  return {
+    type: "message",
+    id: "hidden-source",
+    parentId: null,
+    message: {
+      role: "toolResult",
+      toolCallId: "call-hidden-source",
+      toolName: "bash",
+      content: [{ type: "text", text: "hidden evidence" }],
+    },
+  };
+}
+
+test("Conversation History becomes unavailable when the active visibility snapshot cannot be captured", async () => {
+  const entry = sourceEntry();
+  const ctx = {
+    cwd: "/repo",
+    sessionManager: {
+      getSessionId: () => "session-1",
+      getLeafId: () => entry.id,
+      getBranch: () => [entry],
+      buildContextEntries: () => {
+        throw new Error("visibility snapshot failed");
+      },
+    },
+  };
+  const runtime = new ConversationHistoryRuntime(ctx);
+
+  assert.equal(runtime.capture(false), false);
+  const result = await runtime.search({ query: "hidden evidence" });
+  assert.equal(result.status, "unavailable");
+  assert.equal(result.operation, "search");
+});
+
+test("Conversation History returns a bounded unavailable result when search is aborted", async () => {
+  const entry = sourceEntry();
+  const ctx = {
+    cwd: "/repo",
+    sessionManager: {
+      getSessionId: () => "session-1",
+      getLeafId: () => entry.id,
+      getBranch: () => [entry],
+      buildContextEntries: () => [],
+    },
+  };
+  const runtime = new ConversationHistoryRuntime(ctx);
+  runtime.capture(false);
+  const controller = new AbortController();
+  controller.abort();
+
+  const result = await runtime.search({ query: "hidden evidence" }, controller.signal);
+
+  assert.equal(result.status, "unavailable");
+  assert.equal(result.operation, "search");
+  assert.equal(result.reason, "conversation_history_search_cancelled");
+});
+
+test("Conversation History cancels during a long scan without publishing hits", async () => {
+  const entries = Array.from({ length: 80 }, (_, index) => ({
+    ...sourceEntry(),
+    id: `hidden-source-${index}`,
+    message: {
+      ...sourceEntry().message,
+      toolCallId: `call-hidden-source-${index}`,
+      content: [{ type: "text", text: `hidden evidence ${index} ${"noise ".repeat(80)}` }],
+    },
+  }));
+  const ctx = {
+    cwd: "/repo",
+    sessionManager: {
+      getSessionId: () => "session-1",
+      getLeafId: () => entries.at(-1)?.id,
+      getBranch: () => entries,
+      buildContextEntries: () => [],
+    },
+  };
+  const runtime = new ConversationHistoryRuntime(ctx);
+  runtime.capture(false);
+  let signalReads = 0;
+  const signal = {
+    get aborted() {
+      signalReads += 1;
+      return signalReads > 6;
+    },
+  };
+
+  const result = await runtime.search({ query: "hidden evidence" }, signal);
+
+  assert.equal(result.status, "unavailable");
+  assert.equal(result.reason, "conversation_history_search_cancelled");
+  assert.ok(signalReads > 6);
+});

package/pi-extension/tests/conversation-history/search.test.js

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { searchConversationEntries } from "../../dist/conversation-history/search.js";
+
+function entry(ref, text, kind = "toolResult", position = 0) {
+  return {
+    ref,
+    kind,
+    text,
+    timestamp: `2026-08-23T00:00:0${position}Z`,
+    position,
+  };
+}
+
+test("Conversation History ranks distinct entries by their strongest matching passage", () => {
+  const noisy = entry(
+    "ctx:noisy",
+    `${"authentication succeeded\n".repeat(180)}\nThe database eventually reported a timeout after unrelated output.`,
+    "toolResult",
+    1,
+  );
+  const exact = entry(
+    "ctx:exact",
+    "The authentication request failed because the database timeout expired.",
+    "assistant",
+    2,
+  );
+
+  const result = searchConversationEntries([noisy, exact], { query: "database timeout", limit: 1 });
+
+  assert.equal(result.returned, 1);
+  assert.equal(result.truncated, true);
+  assert.equal(result.hits[0].ref, "ctx:exact");
+  assert.equal(result.hits[0].match.type, "exact-phrase");
+  assert.match(result.hits[0].snippet, /database timeout/i);
+});
+
+test("Conversation History uses the complete filtered corpus for BM25 statistics", () => {
+  const candidate = (length, counts) => {
+    const values = [];
+    for (const [term, count] of Object.entries(counts)) {
+      for (let index = 0; index < count; index += 1) values.push(term, "separator");
+    }
+    while (values.length < length) values.push("filler");
+    return values.slice(0, length).join(" ");
+  };
+  const entries = [
+    entry("ctx:alpha-heavy", candidate(115, { alpha: 5, beta: 7, gamma: 1 }), "assistant", 1),
+    entry("ctx:alpha-gamma", candidate(99, { alpha: 3, gamma: 3 }), "assistant", 2),
+    entry("ctx:gamma-heavy", candidate(163, { gamma: 8 }), "assistant", 3),
+    entry("ctx:beta-only", candidate(134, { beta: 5 }), "assistant", 4),
+    entry("ctx:balanced", candidate(205, { alpha: 7, beta: 3, gamma: 4 }), "assistant", 5),
+    ...Array.from({ length: 60 }, (_, index) =>
+      entry(`ctx:unrelated-${index}`, "filler ".repeat(200), "user", 10 + index),
+    ),
+  ];
+
+  const result = searchConversationEntries(entries, { query: "alpha beta gamma", limit: 5 });
+
+  assert.deepEqual(
+    result.hits.map((hit) => hit.ref),
+    ["ctx:balanced", "ctx:alpha-heavy", "ctx:alpha-gamma", "ctx:beta-only", "ctx:gamma-heavy"],
+  );
+});
+
+test("Conversation History applies kind/tool filters and reports partial lexical matches", () => {
+  const result = searchConversationEntries(
+    [
+      entry("ctx:read", "The database timeout appeared in the read output.", "toolResult", 1),
+      { ...entry("ctx:bash", "The database error appeared in bash output.", "toolResult", 2), toolNames: ["bash"] },
+      entry("ctx:assistant", "The database was discussed.", "assistant", 3),
+    ],
+    { query: "database timeout", kinds: ["toolResult"], toolNames: ["bash"], limit: 8 },
+  );
+
+  assert.deepEqual(
+    result.hits.map((hit) => hit.ref),
+    ["ctx:bash"],
+  );
+  assert.equal(result.hits[0].match.type, "partial-terms");
+  assert.deepEqual(result.hits[0].match.matchedTerms, ["database"]);
+});
+
+test("Conversation History returns one hit per entry and reports lexical zero matches", () => {
+  const result = searchConversationEntries(
+    [
+      entry("ctx:first", "The build completed.", "toolResult", 1),
+      entry("ctx:second", "The tests passed.", "assistant", 2),
+    ],
+    { query: "unrelated phrase", limit: 8 },
+  );
+
+  assert.deepEqual(result.hits, []);
+  assert.equal(result.returned, 0);
+  assert.equal(result.truncated, false);
+});