@hassangameryt/freeflow 0.5.0 → 0.7.0

package/pi-extension/tests/cognitive-routing/profile-resolution.test.js

@@ -0,0 +1,279 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { resolveCognitiveRoutingConfig } from "../../dist/cognitive-routing/config.js";
+import { resolveCognitiveRoutingState } from "../../dist/cognitive-routing/runtime.js";
+import { readCapabilityState } from "../../dist/runtime/runtime-context.js";
+import { PIFLOW_HOST } from "./host-fixture.js";
+
+const standard = {
+  provider: "openai-codex",
+  model: "gpt-5.6-luna",
+  thinkingLevel: "high",
+};
+const reasoning = {
+  provider: "openai-codex",
+  model: "gpt-5.6-sol",
+  thinkingLevel: "max",
+};
+
+function configuredRepository(overrides = {}) {
+  return {
+    cognitiveRouting: {
+      enabled: true,
+      profiles: { standard, reasoning },
+      ...overrides,
+    },
+  };
+}
+
+function createHost({ models = [], unauthenticated = [], clamps = {} } = {}) {
+  const modelMap = new Map(models.map((model) => [`${model.provider}/${model.id}`, model]));
+  const unauthenticatedSet = new Set(unauthenticated);
+  return {
+    modelRegistry: {
+      find(provider, modelId) {
+        return modelMap.get(`${provider}/${modelId}`);
+      },
+      async getApiKeyAndHeaders(model) {
+        return unauthenticatedSet.has(model.provider) ? { ok: false, error: "missing credentials" } : { ok: true };
+      },
+      clampThinkingLevel(model, level) {
+        return clamps[`${model.provider}/${model.id}`]?.[level] ?? level;
+      },
+    },
+  };
+}
+
+const standardModel = { provider: standard.provider, id: standard.model };
+const reasoningModel = { provider: reasoning.provider, id: reasoning.model };
+
+test("resolves two complete repository profiles", () => {
+  const result = resolveCognitiveRoutingConfig(configuredRepository(), {});
+
+  assert.equal(result.valid, true);
+  assert.equal(result.enabled, true);
+  assert.equal(result.enabledSource, "repository");
+  assert.deepEqual(result.profiles, { standard, reasoning });
+  assert.deepEqual(result.profileSources, { standard: "repository", reasoning: "repository" });
+});
+
+test("defaults new-session Cognitive Routing to automatic Reasoning control", () => {
+  const result = resolveCognitiveRoutingConfig(configuredRepository(), {});
+
+  assert.deepEqual(result.sessionStart, { control: "automatic", profile: "reasoning" });
+  assert.deepEqual(result.sessionStartSources, { control: "default", profile: "default" });
+});
+
+test("canonicalizes automatic session starts to Reasoning", () => {
+  const result = resolveCognitiveRoutingConfig(
+    configuredRepository({ sessionStart: { control: "automatic", profile: "standard" } }),
+    {},
+  );
+
+  assert.deepEqual(result.sessionStart, { control: "automatic", profile: "reasoning" });
+  assert.deepEqual(result.sessionStartSources, { control: "repository", profile: "default" });
+});
+
+test("layers session-start control and profile independently", () => {
+  const result = resolveCognitiveRoutingConfig(
+    configuredRepository({ sessionStart: { control: "automatic", profile: "standard" } }),
+    { cognitiveRouting: { sessionStart: { control: "manual", profile: "reasoning" } } },
+  );
+
+  assert.deepEqual(result.sessionStart, { control: "manual", profile: "reasoning" });
+  assert.deepEqual(result.sessionStartSources, { control: "personal", profile: "personal" });
+
+  const inheritedProfile = resolveCognitiveRoutingConfig(
+    configuredRepository({ sessionStart: { control: "manual" } }),
+    { cognitiveRouting: { sessionStart: { profile: "reasoning" } } },
+  );
+  assert.deepEqual(inheritedProfile.sessionStart, { control: "manual", profile: "reasoning" });
+  assert.deepEqual(inheritedProfile.sessionStartSources, { control: "repository", profile: "personal" });
+});
+
+test("replaces a profile atomically from the personal layer", () => {
+  const personalStandard = {
+    provider: "openai-codex",
+    model: "gpt-5.6-luna-personal",
+    thinkingLevel: "medium",
+  };
+  const result = resolveCognitiveRoutingConfig(configuredRepository(), {
+    cognitiveRouting: { profiles: { standard: personalStandard } },
+  });
+
+  assert.equal(result.valid, true);
+  assert.deepEqual(result.profiles.standard, personalStandard);
+  assert.deepEqual(result.profiles.reasoning, reasoning);
+  assert.deepEqual(result.profileSources, { standard: "personal", reasoning: "repository" });
+});
+
+test("rejects a partial personal profile instead of merging fields", () => {
+  const result = resolveCognitiveRoutingConfig(configuredRepository(), {
+    cognitiveRouting: { profiles: { standard: { model: "personal-only" } } },
+  });
+
+  assert.equal(result.valid, false);
+  assert.equal(result.error.code, "invalid_profile");
+  assert.equal(result.error.profile, "standard");
+});
+
+test("keeps Cognitive Routing disabled by default without a config block", async () => {
+  const result = await resolveCognitiveRoutingState({}, {}, createHost({ models: [standardModel, reasoningModel] }));
+
+  assert.equal(result.configured, false);
+  assert.equal(result.enabled, false);
+  assert.equal(result.effective, false);
+  assert.equal(result.blockingReason.code, "disabled");
+});
+
+test("fails only Cognitive Routing closed when its config is invalid", async () => {
+  const result = await resolveCognitiveRoutingState(
+    { cognitiveRouting: { enabled: true, profiles: { standard: { provider: "only-provider" } } } },
+    {},
+    createHost({ models: [standardModel, reasoningModel] }),
+  );
+
+  assert.equal(result.configured, true);
+  assert.equal(result.configValid, false);
+  assert.equal(result.effective, false);
+  assert.equal(result.blockingReason.code, "config_invalid");
+});
+
+test("reports an unsupported host without weakening core capability state", async () => {
+  const result = await resolveCognitiveRoutingState(configuredRepository(), {}, undefined);
+
+  assert.equal(result.enabled, true);
+  assert.equal(result.effective, false);
+  assert.equal(result.blockingReason.code, "host_unsupported");
+});
+
+test("preflights exact identities, authentication, and effective thinking levels", async () => {
+  const host = createHost({
+    models: [standardModel, reasoningModel],
+    clamps: { "openai-codex/gpt-5.6-luna": { high: "high" }, "openai-codex/gpt-5.6-sol": { max: "max" } },
+  });
+  const result = await resolveCognitiveRoutingState(configuredRepository(), {}, host);
+
+  assert.equal(result.effective, true);
+  assert.deepEqual(result.resolvedProfiles.standard, {
+    ...standard,
+    effectiveThinkingLevel: "high",
+  });
+  assert.deepEqual(result.resolvedProfiles.reasoning, {
+    ...reasoning,
+    effectiveThinkingLevel: "max",
+  });
+});
+
+test("normal Pi preflight resolves thinking levels from model metadata without a registry clamp", async () => {
+  const models = [
+    {
+      provider: standard.provider,
+      id: standard.model,
+      reasoning: true,
+      thinkingLevelMap: { xhigh: "xhigh", max: "max" },
+    },
+    {
+      provider: reasoning.provider,
+      id: reasoning.model,
+      reasoning: true,
+      thinkingLevelMap: { xhigh: "xhigh", max: "max" },
+    },
+  ];
+  const modelMap = new Map(models.map((model) => [`${model.provider}/${model.id}`, model]));
+  const host = {
+    modelRegistry: {
+      find(provider, modelId) {
+        return modelMap.get(`${provider}/${modelId}`);
+      },
+      async getApiKeyAndHeaders() {
+        return { ok: true };
+      },
+    },
+  };
+
+  const result = await resolveCognitiveRoutingState(configuredRepository(), {}, host);
+
+  assert.equal(result.effective, true);
+  assert.equal(result.resolvedProfiles.standard.effectiveThinkingLevel, "high");
+  assert.equal(result.resolvedProfiles.reasoning.effectiveThinkingLevel, "max");
+});
+
+test("runtime context isolates invalid Cognitive Routing from core Freeflow state", async () => {
+  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-"));
+  await mkdir(join(cwd, ".freeflow"));
+  const host = createHost({ models: [standardModel, reasoningModel] });
+  try {
+    await writeFile(
+      join(cwd, ".freeflow", "config.json"),
+      JSON.stringify({ cognitiveRouting: configuredRepository().cognitiveRouting }),
+    );
+    let state = await readCapabilityState(cwd, host, PIFLOW_HOST);
+    assert.equal(state.configured, true);
+    assert.equal(state.enabled, true);
+    assert.equal(state.cognitiveRouting.effective, true);
+
+    await writeFile(
+      join(cwd, ".freeflow", "config.json"),
+      JSON.stringify({ enabled: false, cognitiveRouting: configuredRepository().cognitiveRouting }),
+    );
+    state = await readCapabilityState(cwd, host, PIFLOW_HOST);
+    assert.equal(state.enabled, false);
+    assert.equal(state.cognitiveRouting.enabled, false);
+    assert.equal(state.cognitiveRouting.effective, false);
+    assert.equal(state.cognitiveRouting.blockingReason.code, "disabled");
+
+    await writeFile(
+      join(cwd, ".freeflow", "config.json"),
+      JSON.stringify({
+        cognitiveRouting: { enabled: true, profiles: { standard: { provider: "only-provider" } } },
+      }),
+    );
+    state = await readCapabilityState(cwd, host, PIFLOW_HOST);
+    assert.equal(state.configured, true);
+    assert.equal(state.enabled, true);
+    assert.equal(state.cognitiveRouting.configValid, false);
+    assert.equal(state.cognitiveRouting.effective, false);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test("rejects unavailable, unauthenticated, weakened, and identical profile pairs", async () => {
+  const unavailable = await resolveCognitiveRoutingState(
+    configuredRepository(),
+    {},
+    createHost({ models: [standardModel] }),
+  );
+  assert.equal(unavailable.blockingReason.code, "profile_unavailable");
+  assert.equal(unavailable.blockingReason.profile, "reasoning");
+
+  const unauthenticated = await resolveCognitiveRoutingState(
+    configuredRepository(),
+    {},
+    createHost({ models: [standardModel, reasoningModel], unauthenticated: ["openai-codex"] }),
+  );
+  assert.equal(unauthenticated.blockingReason.code, "profile_unauthenticated");
+  assert.equal(unauthenticated.blockingReason.profile, "standard");
+
+  const weakened = await resolveCognitiveRoutingState(
+    configuredRepository(),
+    {},
+    createHost({
+      models: [standardModel, reasoningModel],
+      clamps: { "openai-codex/gpt-5.6-luna": { high: "medium" } },
+    }),
+  );
+  assert.equal(weakened.blockingReason.code, "profile_clamped");
+  assert.equal(weakened.blockingReason.profile, "standard");
+
+  const identical = await resolveCognitiveRoutingState(
+    configuredRepository({ profiles: { standard, reasoning: { ...standard } } }),
+    {},
+    createHost({ models: [standardModel] }),
+  );
+  assert.equal(identical.blockingReason.code, "profiles_identical");
+});

package/pi-extension/tests/cognitive-routing/tool.test.js

@@ -0,0 +1,230 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  COGNITIVE_ROUTING_HISTORY_TOOL_NAME,
+  COGNITIVE_ROUTING_SWITCH_TOOL_NAME,
+  registerCognitiveRoutingHistoryTool,
+  registerCognitiveRoutingTool,
+} from "../../dist/cognitive-routing/tool.js";
+
+function register(getController) {
+  let tool;
+  registerCognitiveRoutingTool(
+    {
+      registerTool(candidate) {
+        tool = candidate;
+      },
+    },
+    getController,
+  );
+  return tool;
+}
+
+function registerHistory(getHistory) {
+  let tool;
+  registerCognitiveRoutingHistoryTool(
+    {
+      registerTool(candidate) {
+        tool = candidate;
+      },
+    },
+    getHistory,
+  );
+  return tool;
+}
+
+test("exposes exactly the bounded profile switch schema", () => {
+  const tool = register(() => undefined);
+
+  assert.equal(tool.name, COGNITIVE_ROUTING_SWITCH_TOOL_NAME);
+  assert.deepEqual(tool.parameters.required, ["target", "reason"]);
+  assert.deepEqual(tool.parameters.properties.target.enum, ["standard", "reasoning"]);
+  assert.equal(tool.parameters.properties.reason.maxLength, 160);
+});
+
+test("validates reason before any controller call", async () => {
+  const tool = register(() => undefined);
+
+  const result = await tool.execute(
+    "call-1",
+    { target: "reasoning", reason: "line one\nline two" },
+    undefined,
+    undefined,
+    {},
+  );
+
+  assert.deepEqual(result.details.result, { status: "blocked", reason: "reason_must_be_single_line" });
+});
+
+test("blocks stale or manually held execution without host mutation", async () => {
+  let calls = 0;
+  const controller = {
+    state() {
+      return { effective: true, controlMode: "manual-reasoning" };
+    },
+    async switchAutomaticProfile() {
+      calls += 1;
+      return { status: "active", profile: "standard" };
+    },
+  };
+  const tool = register(() => controller);
+
+  const result = await tool.execute(
+    "call-2",
+    { target: "standard", reason: "Need a simpler pass." },
+    undefined,
+    undefined,
+    {},
+  );
+
+  assert.deepEqual(result.details.result, { status: "blocked", reason: "manual_hold" });
+  assert.equal(calls, 0);
+});
+
+test("renders no-op results as already active", () => {
+  const tool = register(() => undefined);
+  const theme = {
+    fg(_color, text) {
+      return text;
+    },
+  };
+
+  assert.equal(
+    tool
+      .renderResult(
+        {
+          details: {
+            result: {
+              status: "active",
+              changed: false,
+              from: "reasoning",
+              to: "reasoning",
+              profile: "reasoning",
+            },
+          },
+        },
+        {},
+        theme,
+      )
+      .render(120)
+      .join("\n"),
+    "Cognitive Routing: reasoning (already active)",
+  );
+});
+
+test("recovers a structured result from model-visible tool text", () => {
+  const tool = register(() => undefined);
+  const theme = {
+    fg(_color, text) {
+      return text;
+    },
+  };
+
+  assert.equal(
+    tool
+      .renderResult(
+        { content: [{ type: "text", text: "freeflow_switch_profile|active\\nprofile|reasoning" }], isError: false },
+        {},
+        theme,
+      )
+      .render(120)
+      .join("\n"),
+    "Cognitive Routing: active · reasoning",
+  );
+});
+
+test("hides the duplicate pending line without reading mutable controller state", () => {
+  const tool = register(() => {
+    throw new Error("renderCall must not read live profile state");
+  });
+  const theme = {
+    fg(_color, text) {
+      return text;
+    },
+  };
+
+  assert.deepEqual(tool.renderCall({ target: "reasoning" }, theme).render(120), []);
+  assert.equal(
+    tool
+      .renderResult(
+        {
+          details: {
+            result: {
+              status: "active",
+              changed: true,
+              from: "standard",
+              to: "reasoning",
+              profile: "reasoning",
+            },
+          },
+        },
+        {},
+        theme,
+      )
+      .render(120)
+      .join("\n"),
+    "Cognitive Routing: standard → reasoning",
+  );
+});
+
+test("exposes the read-only Cognitive Routing history tool contract", async () => {
+  const calls = [];
+  const resultValue = {
+    current: { control: "automatic", profile: "reasoning" },
+    summary: { latestSemanticEventId: "intent-1", unresolvedCount: 0, anomalyCount: 0 },
+    events: [],
+  };
+  const tool = registerHistory((options) => {
+    calls.push(options);
+    return resultValue;
+  });
+
+  assert.equal(tool.name, COGNITIVE_ROUTING_HISTORY_TOOL_NAME);
+  assert.deepEqual(tool.parameters.required, []);
+  assert.deepEqual(tool.parameters.properties.scope.enum, ["session", "active-branch"]);
+  assert.equal(tool.parameters.properties.limit.minimum, 1);
+
+  const result = await tool.execute(
+    "history-1",
+    { scope: "active-branch", anomaliesOnly: true, limit: 7 },
+    undefined,
+    undefined,
+    {},
+  );
+
+  assert.deepEqual(calls, [{ scope: "active-branch", anomaliesOnly: true, limit: 7 }]);
+  assert.deepEqual(result.details.result, resultValue);
+  assert.match(result.content[0].text, /Cognitive Routing history/);
+});
+
+test("routes a valid automatic request through the controller", async () => {
+  const calls = [];
+  const controller = {
+    state() {
+      return { effective: true, controlMode: "automatic" };
+    },
+    async switchAutomaticProfile(target, reason) {
+      calls.push([target, reason]);
+      return { status: "active", changed: true, from: "standard", to: target, profile: target };
+    },
+  };
+  const tool = register(() => controller);
+
+  const result = await tool.execute(
+    "call-3",
+    { target: "reasoning", reason: "Need a deeper analysis. " },
+    undefined,
+    undefined,
+    {},
+  );
+
+  assert.deepEqual(calls, [["reasoning", "Need a deeper analysis."]]);
+  assert.deepEqual(result.details.result, {
+    status: "active",
+    changed: true,
+    from: "standard",
+    to: "reasoning",
+    profile: "reasoning",
+  });
+  assert.match(result.content[0].text, /profile\|reasoning/);
+});