@hassangameryt/freeflow 0.7.1 → 0.7.3

package/pi-extension/tests/cache-reuse/history.test.js

@@ -0,0 +1,117 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { RequestHistory } from "../../dist/runtime/request-history.js";
+const state = (text) => ({ role: "custom", customType: "freeflow-runtime-state", content: text, display: false });
+const communication = (text) => ({
+  role: "custom",
+  customType: "freeflow-routing-communication",
+  content: text,
+  display: false,
+});
+const user = (text) => ({ role: "user", content: [{ type: "text", text }], timestamp: 1 });
+function fixture(manager = SessionManager.inMemory("/tmp/freeflow-cache")) {
+  const pi = { appendEntry: (type, data) => manager.appendCustomEntry(type, data) };
+  return { manager, pi, ctx: { sessionManager: manager, ui: { setStatus() {} } }, history: new RequestHistory(pi) };
+}
+test("generated state stays at its original position and changed state appends", async () => {
+  const f = fixture(),
+    one = await f.history.assemble([state("enabled"), user("one")], "ordinary", f.ctx);
+  const two = await f.history.assemble([user("one"), state("disabled"), user("two")], "ordinary", f.ctx);
+  assert.deepEqual(two.slice(0, one.length), one);
+  assert.equal(two.at(-1).content, "disabled");
+  const count = f.manager.getEntries().length;
+  assert.deepEqual(await f.history.assemble([state("disabled"), user("one"), user("two")], "ordinary", f.ctx), two);
+  assert.equal(f.manager.getEntries().length, count);
+  const reload = new RequestHistory(f.pi);
+  const three = await reload.assemble([state("disabled"), user("one"), user("two"), user("three")], "ordinary", f.ctx);
+  assert.deepEqual(three.slice(0, two.length), two);
+});
+test("view changes never import excluded bodies or stale required communication", async () => {
+  const f = fixture();
+  await f.history.assemble([user("SECRET"), state("worker"), communication("required report")], "ordinary", f.ctx);
+  const coordinator = await f.history.assemble([user("selected"), state("coordinator")], "coordinator", f.ctx);
+  assert.ok(!JSON.stringify(coordinator).includes("SECRET"));
+  const reduced = await f.history.assemble([user("new visible"), state("worker")], "ordinary", f.ctx);
+  assert.ok(!JSON.stringify(reduced).includes("SECRET"));
+  assert.ok(!JSON.stringify(reduced).includes("required report"));
+});
+test("context persistence failure returns the current qualified view without old bodies", async () => {
+  const f = fixture();
+  await f.history.assemble([user("old"), state("first")], "ordinary", f.ctx);
+  f.pi.appendEntry = () => {
+    throw Error("disk");
+  };
+  const current = [user("current"), state("second")];
+  assert.equal(await f.history.assemble(current, "ordinary", f.ctx), current);
+});
+
+test("changing only the view label retains the exact permitted prefix", async () => {
+  const f = fixture();
+  const first = await f.history.assemble([user("common"), state("ordinary")], "ordinary", f.ctx);
+  const next = await f.history.assemble([user("common"), state("coordinator")], "coordinator", f.ctx);
+  assert.deepEqual(next.slice(0, first.length), first);
+});
+
+test("native labeled forks preserve generated-state positions", async () => {
+  const root = await mkdtemp(join(tmpdir(), "freeflow-cache-fork-"));
+  try {
+    const manager = SessionManager.create(root, root),
+      f = fixture(manager);
+    const id = manager.appendMessage(user("one"));
+    manager.appendLabelChange(id, "named");
+    const first = await f.history.assemble([user("one"), state("enabled")], "ordinary", f.ctx);
+    manager.appendMessage({
+      role: "assistant",
+      content: [{ type: "text", text: "done" }],
+      timestamp: 2,
+      stopReason: "stop",
+    });
+    const path = manager.createBranchedSession(manager.getLeafId());
+    const nextFixture = fixture(SessionManager.open(path));
+    const next = await nextFixture.history.assemble(
+      [user("one"), user("two"), state("disabled")],
+      "ordinary",
+      nextFixture.ctx,
+    );
+    assert.deepEqual(next.slice(0, first.length), first);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("budget notices see assembled historical overhead and clear without rewriting old notices", async () => {
+  const f = fixture();
+  let length;
+  const first = await f.history.assemble([user("one"), state("enabled")], "ordinary", f.ctx, (messages) => {
+    length = messages.length;
+    return { role: "custom", customType: "freeflow-routing-budget", content: "Large input", display: false };
+  });
+  assert.equal(length, 2);
+  const next = await f.history.assemble([user("one"), user("two"), state("enabled")], "ordinary", f.ctx, (messages) => {
+    length = messages.length;
+  });
+  assert.equal(length, 4);
+  assert.deepEqual(next.slice(0, first.length), first);
+  assert.match(next.at(-1).content, /warning cleared/);
+});
+
+test("ending a restoration obligation retains already admitted communication until context changes", async () => {
+  const f = fixture();
+  const first = await f.history.assemble(
+    [user("one"), communication("accepted report"), state("active")],
+    "ordinary",
+    f.ctx,
+  );
+  const closed = await f.history.assemble([user("one"), user("two"), state("closed")], "ordinary", f.ctx);
+  assert.deepEqual(closed.slice(0, first.length), first);
+  const again = await f.history.assemble(
+    [user("one"), user("two"), communication("accepted report"), state("closed")],
+    "ordinary",
+    f.ctx,
+  );
+  assert.equal(again.filter((message) => message.content === "accepted report").length, 1);
+});

package/pi-extension/tests/cache-reuse/native.test.js

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fixture } from "../fixtures/routing-native.js";
+const profiles = Object.fromEntries(
+  ["coordinator", "helper", "executor"].map((p) => [
+    p,
+    { provider: "openai", model: "gpt-6-astra", thinking: p === "coordinator" ? "high" : "low" },
+  ]),
+);
+for (const projection of [false, true])
+  test(`native routing preserves per-view prefixes with projection=${projection}`, { timeout: 30000 }, async () => {
+    const last = new Map();
+    let ref;
+    const result = await fixture(
+      (n, body, manager) => {
+        const runtimeItems = body.input.filter((x) => JSON.stringify(x).includes("# Cognitive Routing Runtime State"));
+        const current = JSON.stringify(runtimeItems.at(-1));
+        const profile = current.includes("Profile: coordinator") ? "coordinator" : "worker";
+        const view = projection ? profile : "ordinary";
+        const previous = last.get(view);
+        if (previous) {
+          assert.deepEqual(body.tools, previous.tools, "fixed routing tool definitions");
+          assert.deepEqual(
+            body.input.slice(0, previous.input.length),
+            previous.input,
+            `prior ${view} prefix survives request ${n}`,
+          );
+        }
+        last.set(view, body);
+        if (n === 1)
+          return [
+            {
+              name: "freeflow_delegate",
+              args: { operation: "assign", worker: "helper", contract: "Read evidence.txt and select its result." },
+            },
+          ];
+        if (n === 2) return [{ name: "read", args: { path: "evidence.txt" } }];
+        if (n === 3) {
+          ref = "ctx:" + manager.getBranch().find((e) => e.message?.toolName === "read").id;
+          return [
+            ...(projection ? [{ name: "freeflow_project", args: { operation: "add", refs: [ref] } }] : []),
+            { name: "freeflow_return", args: { operation: "submit", report: "Evidence read.", outcome: "completed" } },
+          ];
+        }
+        if (n === 4)
+          return [
+            {
+              name: "freeflow_unit",
+              args: { operation: "close", outcome: "accepted", assessment: "Exact evidence observed." },
+            },
+          ];
+        if (n === 5)
+          return [
+            {
+              name: "freeflow_delegate",
+              args: { operation: "assign", worker: "executor", contract: "Read evidence.txt and return." },
+            },
+          ];
+        if (n === 6) return [{ name: "read", args: { path: "evidence.txt" } }];
+        if (n === 7) {
+          const latest = manager
+            .getBranch()
+            .filter((e) => e.message?.toolName === "read")
+            .at(-1);
+          return [
+            ...(projection
+              ? [{ name: "freeflow_project", args: { operation: "add", refs: ["ctx:" + latest.id] } }]
+              : []),
+            {
+              name: "freeflow_return",
+              args: { operation: "submit", report: "Executor evidence read.", outcome: "completed" },
+            },
+          ];
+        }
+        if (n === 8)
+          return [
+            {
+              name: "freeflow_unit",
+              args: { operation: "close", outcome: "accepted", assessment: "Second exact result checked." },
+            },
+          ];
+        return [];
+      },
+      projection,
+      undefined,
+      false,
+      { cognitiveRouting: { enabled: true, projection, delegation: "both", profiles } },
+    );
+    assert.equal(result.requests.length, 9);
+    assert.ok(result.entries.some((e) => e.customType === "freeflow-request-history-v1"));
+  });

package/pi-extension/tests/cache-reuse/settings.test.js

@@ -0,0 +1,211 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRuntime,
+  SessionManager,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import freeflow from "../../dist/index.js";
+import { response } from "../fixtures/routing-native.js";
+
+test(
+  "native Freeflow settings retain the exact prefix; archive and restore change only real evidence",
+  { timeout: 30000 },
+  async () => {
+    const root = await mkdtemp(join(tmpdir(), "freeflow-settings-cache-")),
+      agentDir = join(root, "agent");
+    await mkdir(agentDir);
+    await mkdir(join(root, ".freeflow"));
+    const config = join(root, ".freeflow/config.json");
+    await writeFile(config, JSON.stringify({ enabled: true }));
+    await writeFile(join(root, "evidence.txt"), "PRIVATE_RAW_EVIDENCE_716");
+    let session, action, ref;
+    const requests = [],
+      errors = [],
+      prior = globalThis.fetch;
+    const manager = SessionManager.create(root, join(root, "sessions"));
+    globalThis.fetch = async (url, init) => {
+      assert.equal(String(url), "https://api.openai.com/v1/responses");
+      const body = JSON.parse(String(init.body));
+      requests.push(body);
+      assert.ok(requests.length <= 20);
+      let calls = [];
+      if (action === "read") {
+        action = undefined;
+        calls = [{ name: "read", args: { path: "evidence.txt" } }];
+      }
+      if (action === "archive") {
+        action = undefined;
+        calls = [
+          {
+            name: "freeflow_context",
+            args: { operation: "archive", targets: [{ ref, retained: "The completed evidence was checked." }] },
+          },
+        ];
+      }
+      if (action === "restore") {
+        action = undefined;
+        calls = [{ name: "freeflow_context", args: { operation: "restore", refs: [ref] } }];
+      }
+      if (action === "denied") {
+        action = undefined;
+        calls = [
+          { name: "freeflow_context", args: { operation: "search", query: "private" } },
+          { name: "freeflow_delegate", args: { operation: "assign", contract: "Must not execute" } },
+        ];
+      }
+      return response(requests.length, calls, "OK");
+    };
+    try {
+      const runtime = await ModelRuntime.create({
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: null,
+        modelsStorePath: join(agentDir, "models.json"),
+        allowModelNetwork: false,
+      });
+      await runtime.setRuntimeApiKey("openai", "fixture-key");
+      const settings = SettingsManager.inMemory({
+        transport: "sse",
+        compaction: { enabled: false },
+        retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
+      });
+      const loader = new DefaultResourceLoader({
+        cwd: root,
+        agentDir,
+        settingsManager: settings,
+        noExtensions: true,
+        noSkills: true,
+        noPromptTemplates: true,
+        noThemes: true,
+        noContextFiles: true,
+        systemPrompt: "Synthetic fixture.",
+        extensionFactories: [freeflow],
+      });
+      await loader.reload();
+      ({ session } = await createAgentSession({
+        cwd: root,
+        agentDir,
+        modelRuntime: runtime,
+        model: runtime.getModel("openai", "gpt-6-astra"),
+        thinkingLevel: "high",
+        settingsManager: settings,
+        sessionManager: manager,
+        resourceLoader: loader,
+      }));
+      await session.bindExtensions({ mode: "print", onError: (e) => errors.push(e) });
+      const prompt = async () => {
+        await session.prompt("Continue the synthetic fixture.");
+        await session.waitForIdle();
+        assert.equal(session.messages.at(-1).stopReason, "stop");
+        assert.deepEqual(errors, []);
+        return requests.at(-1);
+      };
+      action = "read";
+      await prompt();
+      const read = manager.getBranch().find((e) => e.message?.toolName === "read");
+      ref = "ctx:" + read.id;
+      const original = JSON.stringify(read);
+      let previous = requests.at(-1);
+      const stable = async () => {
+        const body = await prompt();
+        assert.deepEqual(body.tools, previous.tools);
+        assert.deepEqual(body.input.slice(0, previous.input.length), previous.input);
+        previous = body;
+      };
+      await session.prompt("/freeflow disable");
+      await stable();
+      action = "denied";
+      await stable();
+      assert.ok(
+        manager
+          .getBranch()
+          .filter((e) => ["freeflow_context", "freeflow_delegate"].includes(e.message?.toolName))
+          .every((e) => e.message.isError),
+      );
+      assert.ok(!manager.getBranch().some((e) => e.customType === "freeflow-routing-v2"));
+      await session.prompt("/freeflow enable");
+      await stable();
+      await writeFile(config, JSON.stringify({ enabled: true, conversationHistory: true }));
+      await session.reload();
+      await stable();
+      await writeFile(
+        config,
+        JSON.stringify({ enabled: true, conversationHistory: true, contextVirtualization: true }),
+      );
+      await session.reload();
+      await stable();
+      await writeFile(join(root, ".freeflow/local.json"), JSON.stringify({ enabled: true }));
+      await session.reload();
+      await stable();
+      const routing = {
+        enabled: true,
+        projection: false,
+        profiles: {
+          coordinator: { provider: "openai", model: "gpt-6-astra", thinking: "high" },
+          executor: { provider: "openai", model: "gpt-6-astra", thinking: "low" },
+        },
+      };
+      await writeFile(
+        config,
+        JSON.stringify({
+          enabled: true,
+          conversationHistory: true,
+          contextVirtualization: true,
+          cognitiveRouting: routing,
+        }),
+      );
+      await session.reload();
+      await stable();
+      await session.prompt("/freeflow profile executor");
+      await stable();
+      await session.prompt("/freeflow profile auto");
+      await stable();
+      routing.profiles.executor.thinking = "medium";
+      await writeFile(
+        config,
+        JSON.stringify({
+          enabled: true,
+          conversationHistory: true,
+          contextVirtualization: true,
+          cognitiveRouting: routing,
+        }),
+      );
+      await session.reload();
+      await stable();
+      routing.projection = true;
+      await writeFile(config, JSON.stringify({ enabled: true, cognitiveRouting: routing }));
+      await session.reload();
+      await stable();
+      routing.projection = false;
+      await writeFile(
+        config,
+        JSON.stringify({
+          enabled: true,
+          conversationHistory: true,
+          contextVirtualization: true,
+          cognitiveRouting: routing,
+        }),
+      );
+      await session.reload();
+      await stable();
+      action = "archive";
+      const archived = await prompt();
+      assert.ok(!JSON.stringify(archived).includes("PRIVATE_RAW_EVIDENCE_716"));
+      assert.deepEqual(archived.tools, previous.tools);
+      action = "restore";
+      const restored = await prompt();
+      assert.ok(JSON.stringify(restored).includes("PRIVATE_RAW_EVIDENCE_716"));
+      assert.deepEqual(restored.tools, previous.tools);
+      assert.equal(JSON.stringify(manager.getEntry(read.id)), original, "canonical evidence untouched");
+    } finally {
+      session?.dispose();
+      globalThis.fetch = prior;
+      await rm(root, { recursive: true, force: true });
+    }
+  },
+);