@hassangameryt/freeflow 0.7.2 → 0.8.0

package/pi-extension/tests/fixtures/routing-native.js

@@ -1,188 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  createAgentSession,
-  DefaultResourceLoader,
-  ModelRuntime,
-  SessionManager,
-  SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import freeflow from "../../dist/index.js";
-import { replay } from "../../dist/cognitive-routing-v2/state.js";
-
-export function response(n, calls = [], text = "fixture response") {
-  const output = [
-    {
-      type: "message",
-      id: `msg-${n}`,
-      role: "assistant",
-      status: "completed",
-      content: [{ type: "output_text", text, annotations: [] }],
-    },
-    ...calls.map((c, i) => ({
-      type: "function_call",
-      id: `fc_${n}_${i}`,
-      call_id: `call-${n}-${i}`,
-      name: c.name,
-      arguments: JSON.stringify(c.args),
-    })),
-  ];
-  const events = [{ type: "response.created", response: { id: `r-${n}`, status: "in_progress", output: [] } }];
-  output.forEach((item, i) => {
-    events.push({
-      type: "response.output_item.added",
-      output_index: i,
-      item: item.type === "message" ? { ...item, content: [] } : { ...item, arguments: "" },
-    });
-    if (item.type === "message")
-      events.push({ type: "response.output_text.delta", output_index: i, content_index: 0, delta: text });
-    else
-      events.push(
-        { type: "response.function_call_arguments.delta", output_index: i, delta: item.arguments },
-        { type: "response.function_call_arguments.done", output_index: i, arguments: item.arguments },
-      );
-    events.push({ type: "response.output_item.done", output_index: i, item });
-  });
-  events.push({
-    type: "response.completed",
-    response: {
-      id: `r-${n}`,
-      status: "completed",
-      output,
-      usage: { input_tokens: 10, output_tokens: 10, total_tokens: 20 },
-    },
-  });
-  return new Response(events.map((e) => `data: ${JSON.stringify(e)}\n\n`).join("") + "data: [DONE]\n\n", {
-    status: 200,
-    headers: { "content-type": "text/event-stream" },
-  });
-}
-
-export async function fixture(script, projection = true, after, withUI = true, options = {}) {
-  const root = await mkdtemp(join(tmpdir(), "freeflow-v2-native-"));
-  const cwd = join(root, "cwd"),
-    agentDir = join(root, "agent");
-  await mkdir(join(cwd, ".freeflow"), { recursive: true });
-  await mkdir(agentDir);
-  await writeFile(
-    join(cwd, ".freeflow/config.json"),
-    JSON.stringify({
-      cognitiveRouting: {
-        enabled: true,
-        projection,
-        profiles: {
-          coordinator: { provider: "openai", model: "gpt-4o", thinking: "off" },
-          executor: { provider: "openai", model: "gpt-4.1-mini", thinking: "off" },
-        },
-      },
-    }),
-  );
-  await writeFile(join(cwd, "evidence.txt"), "EXACT_EVIDENCE_BODY_81");
-  await writeFile(join(cwd, "unselected.txt"), "UNSELECTED_PRIVATE_BODY_93");
-  await writeFile(
-    join(agentDir, "models.json"),
-    JSON.stringify({ providers: { openai: { baseUrl: "https://fixture.invalid/v1" } } }),
-  );
-  const priorFetch = globalThis.fetch,
-    offline = process.env.PI_OFFLINE;
-  process.env.PI_OFFLINE = "1";
-  const requests = [],
-    errors = [],
-    contexts = [],
-    transportFailures = [],
-    notices = [];
-  let session;
-  const manager = SessionManager.create(cwd, join(root, "sessions"));
-  globalThis.fetch = async (url, init) => {
-    assert.match(String(url), /^https:\/\/fixture\.invalid\//, "no unexpected network destination");
-    const body = JSON.parse(String(init.body));
-    requests.push(body);
-    assert.ok(requests.length <= (options.maxRequests ?? 15), "bounded fixture request count");
-    try {
-      const calls = await script(requests.length, body, manager, requests);
-      return options.response ? options.response(requests.length, calls) : response(requests.length, calls);
-    } catch (error) {
-      transportFailures.push(error);
-      throw error;
-    }
-  };
-  try {
-    const modelRuntime = await ModelRuntime.create({
-      authPath: join(agentDir, "auth.json"),
-      modelsPath: join(agentDir, "models.json"),
-      modelsStorePath: join(agentDir, "models-store.json"),
-      allowModelNetwork: false,
-    });
-    await modelRuntime.setRuntimeApiKey("openai", "fixture-not-a-real-key");
-    const settingsManager = SettingsManager.inMemory({
-      compaction: { enabled: false, keepRecentTokens: 1, reserveTokens: 1 },
-      retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
-      ...options.settings,
-    });
-    const loader = new DefaultResourceLoader({
-      cwd,
-      agentDir,
-      settingsManager,
-      noExtensions: true,
-      noSkills: true,
-      noPromptTemplates: true,
-      noThemes: true,
-      noContextFiles: true,
-      extensionFactories: [
-        freeflow,
-        ...(options.extensions ?? []),
-        (pi) => {
-          pi.on("context", (event) => {
-            contexts.push(structuredClone(event.messages));
-          });
-          pi.on("session_before_compact", () => ({
-            compaction: {
-              summary: "Fixture compacted prior work; evidence must come from canonical sources.",
-              firstKeptEntryId: manager.getLeafId(),
-              tokensBefore: 100,
-            },
-          }));
-        },
-      ],
-    });
-    await loader.reload();
-    assert.deepEqual(loader.getExtensions().errors, []);
-    ({ session } = await createAgentSession({
-      cwd,
-      agentDir,
-      modelRuntime,
-      model: modelRuntime.getModel("openai", "gpt-4o"),
-      thinkingLevel: "off",
-      settingsManager,
-      sessionManager: manager,
-      resourceLoader: loader,
-    }));
-    // Public retained bindings make Pi emit session_start again on SDK reload, including headless mode.
-    await session.bindExtensions({
-      mode: "print",
-      onError: (e) => errors.push(e),
-      ...(withUI ? { uiContext: { notify: (...args) => notices.push(args), setStatus: () => {} } } : {}),
-    });
-    await options.onSession?.(session);
-    await session.prompt("Complete the fixture assignment.");
-    await session.waitForIdle();
-    assert.deepEqual(errors, [], "extension lifecycle errors");
-    if (after) await after({ session, manager, requests, contexts, cwd, notices });
-    assert.deepEqual(errors, [], "post-lifecycle errors");
-    assert.deepEqual(transportFailures, [], "scripted provider assertions must not be swallowed as provider errors");
-    assert.notEqual(
-      session.messages.at(-1)?.stopReason,
-      "error",
-      `fixture completes without provider failure: ${session.messages.at(-1)?.errorMessage ?? ""}`,
-    );
-    return { requests, state: replay(manager.getBranch()), entries: manager.getEntries(), contexts };
-  } finally {
-    session?.dispose();
-    globalThis.fetch = priorFetch;
-    if (offline === undefined) delete process.env.PI_OFFLINE;
-    else process.env.PI_OFFLINE = offline;
-    await rm(root, { recursive: true, force: true });
-  }
-}

package/pi-extension/tests/integration/mode-free-core.test.js

@@ -1,219 +0,0 @@
-import assert from "node:assert/strict";
-import { cp, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { tmpdir } from "node:os";
-import test from "node:test";
-
-import freeflowExtension from "../../dist/index.js";
-import {
-  freeflowRuntimeStateMessage,
-  getRuntimeContext,
-  readCapabilityState,
-  readFreeflowConfigLayers,
-  runtimeContext,
-  setSessionCoreOverride,
-} from "../../dist/runtime/runtime-context.js";
-import { PIFLOW_HOST } from "../fixtures/pi-host.js";
-
-function context(cwd) {
-  const notifications = [];
-  return {
-    cwd,
-    notifications,
-    ui: {
-      setStatus() {},
-      notify(message, level) {
-        notifications.push({ message, level });
-      },
-    },
-    sessionManager: {
-      getBranch: () => [],
-      getEntries: () => [],
-    },
-  };
-}
-
-function loadExtension(extension = freeflowExtension) {
-  const handlers = new Map();
-  const commands = [];
-  const sentMessages = [];
-  const tools = [];
-  const pi = {
-    host: PIFLOW_HOST,
-    registerCommand(name, definition) {
-      commands.push({ name, definition });
-    },
-    registerTool(tool) {
-      tools.push(tool);
-    },
-    sendUserMessage(message) {
-      sentMessages.push(message);
-    },
-    registerShortcut() {},
-    on(name, handler) {
-      handlers.set(name, handler);
-    },
-    getAllTools() {
-      return tools.map((tool) => ({ name: tool.name }));
-    },
-    getActiveTools() {
-      return tools.map((tool) => tool.name);
-    },
-    setActiveTools() {},
-  };
-  extension(pi);
-  return { handlers, commands, sentMessages };
-}
-
-async function configuredRepo(config = {}) {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-mode-free-core-"));
-  await mkdir(join(cwd, ".freeflow"));
-  await writeFile(join(cwd, ".freeflow/config.json"), JSON.stringify(config), "utf8");
-  return cwd;
-}
-
-test("obsolete mode and core-toggle configuration keys are rejected", async () => {
-  for (const config of [{ defaultMode: "workflow" }, { interactionContract: false }, { skills: { enabled: false } }]) {
-    const cwd = await configuredRepo(config);
-    try {
-      const layers = await readFreeflowConfigLayers(cwd);
-      assert.equal(layers.configured, false);
-      assert.equal(layers.repository.valid, false);
-      assert.match(layers.parseError, /unsupported top-level config key/);
-    } finally {
-      await rm(cwd, { recursive: true, force: true });
-    }
-  }
-});
-
-test("an empty valid config enables the single Freeflow core", async () => {
-  const cwd = await configuredRepo();
-  try {
-    const state = await readCapabilityState(cwd, undefined, PIFLOW_HOST);
-    assert.equal(state.configured, true);
-    assert.equal(state.enabled, true);
-    assert.deepEqual(state.configuredCoreConfig, {
-      enabled: true,
-      contextVirtualization: false,
-      conversationHistory: false,
-    });
-    assert.equal("defaultMode" in state, false);
-    assert.equal("interactionContract" in state, false);
-    assert.equal("skills" in state, false);
-    assert.equal("defaultMode" in state.configSources, false);
-    assert.equal("interactionContract" in state.configSources, false);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("core and the separately editable Interaction Contract are mandatory prompt fragments", async () => {
-  const cwd = await configuredRepo();
-  try {
-    const state = await readCapabilityState(cwd, undefined, PIFLOW_HOST);
-    const loaded = await getRuntimeContext(state);
-    assert.match(loaded.corePrompt, /# Freeflow Stable Guidance/);
-    assert.match(loaded.corePrompt, /## Recover After Context Loss/);
-    assert.match(loaded.corePrompt, /## Shared Terms/);
-    assert.match(loaded.corePrompt, /Report the outcome, evidence, limits, and current route\./);
-    assert.equal(loaded.skillsPrompt, undefined);
-    assert.match(loaded.interactionContractPrompt, /# Freeflow Interaction Contract/);
-    assert.match(runtimeContext(loaded, state), /# Freeflow Stable Guidance/);
-    assert.match(runtimeContext(loaded, state), /# Freeflow Interaction Contract/);
-    assert.match(freeflowRuntimeStateMessage(state).content, /Freeflow: unavailable/);
-
-    const missingContract = { ...loaded, interactionContractPrompt: null };
-    assert.equal(runtimeContext(missingContract, state), "");
-    assert.equal(runtimeContext({ ...loaded, interactionContractPrompt: " \n\t" }, state), "");
-    assert.equal(runtimeContext({ ...loaded, corePrompt: " \n\t" }, state), "");
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("Pi exposes base skills without mode or Skills controls", async () => {
-  const cwd = await configuredRepo();
-  try {
-    const { handlers, commands } = loadExtension();
-    const ctx = context(cwd);
-    const resources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.equal(resources.skillPaths.length, 24);
-    assert.ok(resources.skillPaths.some((path) => path.endsWith("/skills/workflow/SKILL.md")));
-    assert.ok(!resources.skillPaths.some((path) => path.endsWith("/skills/tdd/SKILL.md")));
-    assert.ok(!resources.skillPaths.some((path) => path.endsWith("/skills/mode-contract/SKILL.md")));
-
-    const freeflowCommand = commands.find((command) => command.name === "freeflow");
-    assert.ok(freeflowCommand);
-    assert.ok(!freeflowCommand.definition.getArgumentCompletions("").some((item) => item.value === "mode"));
-    assert.deepEqual(freeflowCommand.definition.getArgumentCompletions("mode "), []);
-
-    const before = await handlers.get("before_agent_start")({ systemPrompt: "base" }, ctx);
-    assert.match(before.systemPrompt, /# Freeflow Stable Guidance/);
-    assert.match(before.systemPrompt, /# Freeflow Interaction Contract/);
-    assert.match(before.systemPrompt, /## Shared Terms/);
-    assert.doesNotMatch(before.systemPrompt, /## Mode\b|strict-workflow|conversation mode|workflow mode/);
-    assert.doesNotMatch(before.systemPrompt, /Skills prompt/);
-
-    const providerContext = await handlers.get("context")({ messages: [] }, ctx);
-    const stateMessage = providerContext.messages.at(-1);
-    assert.match(stateMessage.content, /Freeflow: active/);
-    assert.doesNotMatch(stateMessage.content, /Default mode|Active mode|Interaction Contract|Skills/);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("mandatory prompt readiness gates Runtime State, discovery, and direct skill dispatch", async () => {
-  const root = await mkdtemp(join(tmpdir(), "freeflow-mandatory-prompt-readiness-"));
-  const cwd = await configuredRepo();
-  try {
-    await cp(join(process.cwd(), "pi-extension", "dist"), join(root, "pi-extension", "dist"), { recursive: true });
-    await cp(join(process.cwd(), "runtime", "prompts"), join(root, "runtime", "prompts"), { recursive: true });
-    await symlink(join(process.cwd(), "node_modules"), join(root, "node_modules"), "dir");
-    await rm(join(root, "runtime", "prompts", "interaction-contract.md"));
-
-    const extension = (
-      await import(
-        `${pathToFileURL(join(root, "pi-extension", "dist", "index.js")).href}?missing-contract=${Date.now()}`
-      )
-    ).default;
-    const { handlers, commands, sentMessages } = loadExtension(extension);
-    const ctx = context(cwd);
-    const before = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.equal(before.systemPrompt, "base prompt");
-    const resources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.deepEqual(resources.skillPaths, []);
-
-    const discuss = commands.find((command) => command.name === "discuss");
-    assert.ok(discuss);
-    await discuss.definition.handler(undefined, ctx);
-    assert.deepEqual(sentMessages, []);
-    assert.match(ctx.notifications.at(-1).message, /Freeflow core prompts are unavailable/i);
-
-    const providerContext = await handlers.get("context")({ messages: [] }, ctx);
-    assert.match(providerContext.messages.at(-1).content, /Freeflow: unavailable/);
-    assert.doesNotMatch(providerContext.messages.at(-1).content, /Freeflow: active/);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("session overrides are limited to the remaining configurable core values", async () => {
-  const cwd = await configuredRepo();
-  try {
-    const { commands } = loadExtension();
-    const ctx = context(cwd);
-    const pi = { appendEntry() {}, host: PIFLOW_HOST };
-    const result = await setSessionCoreOverride("enabled", false, ctx, pi);
-    assert.equal(result.changed, true);
-    await assert.rejects(() => setSessionCoreOverride("interactionContract", false, ctx, pi), /Invalid Freeflow/);
-    await assert.rejects(() => setSessionCoreOverride("skillsEnabled", false, ctx, pi), /Invalid Freeflow/);
-    assert.ok(commands.some((command) => command.name === "freeflow"));
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-await readFile(join(process.cwd(), "runtime", "prompts", "interaction-contract.md"), "utf8");