@hassangameryt/freeflow 0.7.3 → 0.8.0

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

@@ -1,110 +0,0 @@
-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

@@ -1,230 +0,0 @@
-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 keeps original content and the stable reference marker", async () => {
-  const { runtime } = createFixture();
-  const result = await runtime.project([toolMessage()], false);
-  assert.equal(result.changed, true);
-  assert.deepEqual(result.messages[0].content.slice(0, -1), [{ type: "text", text: "secret raw output" }]);
-  assert.match(result.messages[0].content.at(-1).text, /context-ref: ctx:tool-1/);
-});
-
-test("unavailable decoration leaves the already projected view intact", () => {
-  const { runtime } = createFixture();
-  runtime.setContext({
-    sessionManager: {
-      getBranch() {
-        throw Error("unavailable");
-      },
-    },
-  });
-  const current = [{ role: "custom", customType: "blocked", content: "Only this safe view" }];
-  assert.equal(runtime.decorate(current), current);
-});

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

@@ -1,98 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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);
-});

package/pi-extension/tests/fixtures/pi-host.js

@@ -1,4 +0,0 @@
-export const PIFLOW_HOST = Object.freeze({
-  distribution: Object.freeze({ id: "piflow", version: "test" }),
-  capabilities: Object.freeze({ sessionModelStateControl: 1 }),
-});