@hassangameryt/freeflow 0.7.3 → 0.9.0

package/pi-extension/src/ui/text-component.ts

@@ -1,66 +0,0 @@
-export function textComponent(text: any) {
-  return {
-    render(width = 120) {
-      const maxWidth = Number.isFinite(width) ? Math.max(1, width) : 120;
-      return String(text)
-        .split("\n")
-        .map((line) => truncateAnsiToWidth(line, maxWidth));
-    },
-    invalidate() {},
-  };
-}
-
-function truncateAnsiToWidth(input: any, width: number): string {
-  const text = String(input);
-  let output = "";
-  let visible = 0;
-
-  for (let index = 0; index < text.length;) {
-    const ansi = readAnsiSequence(text, index);
-    if (ansi) {
-      output += ansi.sequence;
-      index = ansi.end;
-      continue;
-    }
-
-    if (visible >= width - 1) {
-      output += "…";
-      return output;
-    }
-
-    const codePoint = text.codePointAt(index) ?? 0;
-    const character = String.fromCodePoint(codePoint);
-    output += character;
-    visible += 1;
-    index += character.length;
-  }
-
-  return output;
-}
-
-function readAnsiSequence(text: string, index: number): { sequence: string; end: number } | null {
-  if (text.charCodeAt(index) !== 0x1b) {
-    return null;
-  }
-
-  const next = text[index + 1];
-  if (next === "[") {
-    let end = index + 2;
-    while (end < text.length && !/[\x40-\x7e]/.test(text[end] ?? "")) {
-      end += 1;
-    }
-    const boundedEnd = Math.min(end + 1, text.length);
-    return { sequence: text.slice(index, boundedEnd), end: boundedEnd };
-  }
-
-  if (next === "]") {
-    const bellEnd = text.indexOf("\x07", index + 2);
-    const stEnd = text.indexOf("\x1b\\", index + 2);
-    const candidates = [bellEnd, stEnd === -1 ? -1 : stEnd + 1].filter((value) => value !== -1);
-    const end = candidates.length > 0 ? Math.min(...candidates) + 1 : text.length;
-    return { sequence: text.slice(index, end), end };
-  }
-
-  const end = Math.min(index + 2, text.length);
-  return { sequence: text.slice(index, end), end };
-}

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

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

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

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