@hassangameryt/freeflow 0.5.0 → 0.7.0

package/pi-extension/dist/ui/text-component.js

@@ -0,0 +1,57 @@
+export function textComponent(text) {
+  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, width) {
+  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, index) {
+  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/src/cognitive-routing/commands.ts

@@ -0,0 +1,129 @@
+import type { CognitiveRoutingHistoryOptions, CognitiveRoutingHistoryResult } from "./history.js";
+import type { CognitiveRoutingProfileName } from "./types.js";
+
+const PROFILE_VALUES = ["standard", "reasoning", "auto"] as const;
+const HISTORY_VALUES = ["history", "history active", "history anomalies"] as const;
+
+type ProfileCommandContext = {
+  isIdle?: () => boolean;
+  ui?: { notify?: (message: string, level?: "info" | "warning" | "error") => void };
+  history?: (
+    options: CognitiveRoutingHistoryOptions,
+  ) => CognitiveRoutingHistoryResult | Promise<CognitiveRoutingHistoryResult>;
+};
+
+type CognitiveRoutingProfileController = {
+  history?: (
+    options: CognitiveRoutingHistoryOptions,
+  ) => CognitiveRoutingHistoryResult | Promise<CognitiveRoutingHistoryResult>;
+  setManualProfile(
+    profile: CognitiveRoutingProfileName,
+    mechanism?: string,
+  ): Promise<{ status: string; profile?: CognitiveRoutingProfileName; reason?: string }>;
+  setAutomaticControl(mechanism?: string): Promise<{ status: string; reason?: string }>;
+};
+
+export function cognitiveRoutingProfileCompletions(prefix: string | undefined) {
+  const query = prefix ?? "";
+  return [...PROFILE_VALUES, ...HISTORY_VALUES]
+    .filter((value) => value.startsWith(query))
+    .map((value) => ({
+      value,
+      label: value,
+      description:
+        value === "auto"
+          ? "Release the manual hold and use the Reasoning profile"
+          : value === "history"
+            ? "Show Cognitive Routing transition history"
+            : value === "history active"
+              ? "Show current-branch Cognitive Routing history"
+              : value === "history anomalies"
+                ? "Show Cognitive Routing history anomalies"
+                : `Hold ${value} profile manually`,
+    }));
+}
+
+function historyOptions(value: string): CognitiveRoutingHistoryOptions | undefined {
+  if (value === "history") return {};
+  if (value === "history active") return { scope: "active-branch" };
+  if (value === "history anomalies") return { anomaliesOnly: true };
+  return undefined;
+}
+
+function formatHistory(result: CognitiveRoutingHistoryResult): string {
+  const lines = [
+    `Cognitive Routing history: ${result.current.profile} · ${result.current.control}`,
+    `Events: ${result.events.length}; unresolved=${result.summary.unresolvedCount}; anomalies=${result.summary.anomalyCount}`,
+  ];
+  if (result.summary.latestSemanticEventId) lines.push(`Latest semantic: ${result.summary.latestSemanticEventId}`);
+  if (result.summary.latestCompletedEventId) lines.push(`Latest completed: ${result.summary.latestCompletedEventId}`);
+  for (const event of result.events) {
+    const transition = event.from && event.to ? ` ${event.from} → ${event.to}` : "";
+    lines.push(
+      `${event.jsonlPosition}: ${event.outcome} · ${event.classification}${transition} · changed=${event.changed} · ${event.id}`,
+    );
+  }
+  return lines.join("\n");
+}
+
+export async function handleCognitiveRoutingProfileCommand(
+  args: string | undefined,
+  ctx: ProfileCommandContext,
+  controller: CognitiveRoutingProfileController | undefined,
+): Promise<boolean> {
+  const input = (args ?? "").trim().toLowerCase();
+  const [action, ...rest] = input.split(/\s+/);
+  if (action !== "profile") return false;
+
+  const value = rest.join(" ");
+  const historyView = historyOptions(value);
+  if (historyView) {
+    const result = ctx.history
+      ? await ctx.history(historyView)
+      : controller?.history
+        ? await controller.history(historyView)
+        : undefined;
+    if (result) {
+      ctx.ui?.notify?.(formatHistory(result), "info");
+    } else {
+      ctx.ui?.notify?.("Cognitive Routing history is unavailable for this session.", "warning");
+    }
+    return true;
+  }
+  if (!PROFILE_VALUES.includes(value as (typeof PROFILE_VALUES)[number])) {
+    ctx.ui?.notify?.(
+      "Usage: /freeflow profile standard, /freeflow profile reasoning, /freeflow profile auto, or /freeflow profile history [active|anomalies]",
+      "warning",
+    );
+    return true;
+  }
+  if (typeof ctx.isIdle === "function" && !ctx.isIdle()) {
+    ctx.ui?.notify?.("Freeflow settings and profile changes are available only while Pi is idle.", "warning");
+    return true;
+  }
+  if (!controller) {
+    ctx.ui?.notify?.(
+      "Cognitive Routing is unavailable for this session. It may be disabled, unsupported by the Pi host, or suppressed by an explicit startup model selection.",
+      "warning",
+    );
+    return true;
+  }
+
+  if (value === "auto") {
+    const result = await controller.setAutomaticControl();
+    if (result.status === "automatic") {
+      ctx.ui?.notify?.("Cognitive Routing manual hold released; automatic Reasoning control is active.", "info");
+    } else {
+      ctx.ui?.notify?.(`Cognitive Routing could not release the manual hold: ${result.reason}.`, "warning");
+    }
+    return true;
+  }
+
+  const result = await controller.setManualProfile(value as CognitiveRoutingProfileName);
+  if (result.status === "active") {
+    ctx.ui?.notify?.(`Cognitive Routing manual hold set to ${result.profile}.`, "info");
+  } else {
+    ctx.ui?.notify?.(`Cognitive Routing could not set the manual profile: ${result.reason}.`, "warning");
+  }
+  return true;
+}

package/pi-extension/src/cognitive-routing/config.ts

@@ -0,0 +1,303 @@
+import {
+  COGNITIVE_ROUTING_PROFILE_NAMES,
+  COGNITIVE_ROUTING_SESSION_START_CONTROLS,
+  DEFAULT_COGNITIVE_ROUTING_SESSION_START,
+  type CognitiveRoutingConfigError,
+  type CognitiveRoutingConfigResolution,
+  type CognitiveRoutingConfigSource,
+  type CognitiveRoutingProfile,
+  type CognitiveRoutingProfileName,
+  type CognitiveRoutingSessionStart,
+  type CognitiveRoutingSessionStartControl,
+  type CognitiveRoutingThinkingLevel,
+} from "./types.js";
+
+const THINKING_LEVELS = new Set<CognitiveRoutingThinkingLevel>([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+]);
+const PROFILE_NAME_SET = new Set<string>(COGNITIVE_ROUTING_PROFILE_NAMES);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function invalid(
+  source: "repository" | "personal",
+  code: CognitiveRoutingConfigError["code"],
+  message: string,
+  profile?: CognitiveRoutingProfileName,
+): CognitiveRoutingConfigError {
+  return { code, message, ...(profile ? { profile } : {}), source };
+}
+
+function parseProfile(
+  value: unknown,
+  source: "repository" | "personal",
+  name: CognitiveRoutingProfileName,
+): { profile?: CognitiveRoutingProfile; error?: CognitiveRoutingConfigError } {
+  if (!isRecord(value)) {
+    return { error: invalid(source, "invalid_profile", `${source} ${name} profile must be an object`, name) };
+  }
+
+  const allowedKeys = new Set(["provider", "model", "thinkingLevel"]);
+  const unsupportedKey = Object.keys(value).find((key) => !allowedKeys.has(key));
+  if (unsupportedKey) {
+    return {
+      error: invalid(
+        source,
+        "unsupported_key",
+        `${source} ${name} profile contains unsupported key: ${unsupportedKey}`,
+        name,
+      ),
+    };
+  }
+
+  if (typeof value.provider !== "string" || value.provider.trim() === "") {
+    return { error: invalid(source, "invalid_profile", `${source} ${name} profile requires provider`, name) };
+  }
+  if (typeof value.model !== "string" || value.model.trim() === "") {
+    return { error: invalid(source, "invalid_profile", `${source} ${name} profile requires model`, name) };
+  }
+  if (
+    typeof value.thinkingLevel !== "string" ||
+    !THINKING_LEVELS.has(value.thinkingLevel as CognitiveRoutingThinkingLevel)
+  ) {
+    return {
+      error: invalid(source, "invalid_profile", `${source} ${name} profile requires a valid thinkingLevel`, name),
+    };
+  }
+
+  return {
+    profile: {
+      provider: value.provider,
+      model: value.model,
+      thinkingLevel: value.thinkingLevel as CognitiveRoutingThinkingLevel,
+    },
+  };
+}
+
+interface ParsedLayer {
+  present: boolean;
+  valid: boolean;
+  enabled?: boolean;
+  profiles: Partial<Record<CognitiveRoutingProfileName, CognitiveRoutingProfile>>;
+  sessionStart: Partial<CognitiveRoutingSessionStart>;
+  error?: CognitiveRoutingConfigError;
+}
+
+function parseSessionStart(
+  value: unknown,
+  source: "repository" | "personal",
+): { sessionStart?: Partial<CognitiveRoutingSessionStart>; error?: CognitiveRoutingConfigError } {
+  if (!isRecord(value)) {
+    return {
+      error: invalid(source, "invalid_session_start", `${source} cognitiveRouting.sessionStart must be an object`),
+    };
+  }
+
+  const allowedKeys = new Set(["control", "profile"]);
+  const unsupportedKey = Object.keys(value).find((key) => !allowedKeys.has(key));
+  if (unsupportedKey) {
+    return {
+      error: invalid(
+        source,
+        "unsupported_key",
+        `${source} cognitiveRouting.sessionStart contains unsupported key: ${unsupportedKey}`,
+      ),
+    };
+  }
+
+  let control: CognitiveRoutingSessionStartControl | undefined;
+  if (Object.hasOwn(value, "control")) {
+    if (
+      typeof value.control !== "string" ||
+      !COGNITIVE_ROUTING_SESSION_START_CONTROLS.includes(value.control as CognitiveRoutingSessionStartControl)
+    ) {
+      return {
+        error: invalid(
+          source,
+          "invalid_session_start",
+          `${source} cognitiveRouting.sessionStart.control must be automatic or manual`,
+        ),
+      };
+    }
+    control = value.control as CognitiveRoutingSessionStartControl;
+  }
+
+  let profile: CognitiveRoutingProfileName | undefined;
+  if (Object.hasOwn(value, "profile")) {
+    if (typeof value.profile !== "string" || !PROFILE_NAME_SET.has(value.profile)) {
+      return {
+        error: invalid(
+          source,
+          "invalid_session_start",
+          `${source} cognitiveRouting.sessionStart.profile must be standard or reasoning`,
+        ),
+      };
+    }
+    profile = value.profile as CognitiveRoutingProfileName;
+  }
+
+  return { sessionStart: { ...(control ? { control } : {}), ...(profile ? { profile } : {}) } };
+}
+
+function parseLayer(value: unknown, source: "repository" | "personal"): ParsedLayer {
+  if (value === undefined) {
+    return { present: false, valid: true, profiles: {}, sessionStart: {} };
+  }
+  if (!isRecord(value)) {
+    return {
+      present: true,
+      valid: false,
+      profiles: {},
+      sessionStart: {},
+      error: invalid(source, "invalid_block", `${source} cognitiveRouting must be an object`),
+    };
+  }
+
+  const allowedKeys = new Set(["enabled", "profiles", "sessionStart"]);
+  const unsupportedKey = Object.keys(value).find((key) => !allowedKeys.has(key));
+  if (unsupportedKey) {
+    return {
+      present: true,
+      valid: false,
+      profiles: {},
+      sessionStart: {},
+      error: invalid(
+        source,
+        "unsupported_key",
+        `${source} cognitiveRouting contains unsupported key: ${unsupportedKey}`,
+      ),
+    };
+  }
+
+  let enabled: boolean | undefined;
+  if (Object.hasOwn(value, "enabled")) {
+    if (typeof value.enabled !== "boolean") {
+      return {
+        present: true,
+        valid: false,
+        profiles: {},
+        sessionStart: {},
+        error: invalid(source, "invalid_enabled", `${source} cognitiveRouting.enabled must be a boolean`),
+      };
+    }
+    enabled = value.enabled;
+  }
+
+  let sessionStart: Partial<CognitiveRoutingSessionStart> = {};
+  if (Object.hasOwn(value, "sessionStart")) {
+    const parsed = parseSessionStart(value.sessionStart, source);
+    if (parsed.error)
+      return { present: true, valid: false, enabled, profiles: {}, sessionStart: {}, error: parsed.error };
+    sessionStart = parsed.sessionStart ?? {};
+  }
+
+  const profiles: Partial<Record<CognitiveRoutingProfileName, CognitiveRoutingProfile>> = {};
+  if (Object.hasOwn(value, "profiles")) {
+    if (!isRecord(value.profiles)) {
+      return {
+        present: true,
+        valid: false,
+        profiles: {},
+        sessionStart: {},
+        error: invalid(source, "invalid_profiles", `${source} cognitiveRouting.profiles must be an object`),
+      };
+    }
+
+    const unsupportedProfile = Object.keys(value.profiles).find((key) => !PROFILE_NAME_SET.has(key));
+    if (unsupportedProfile) {
+      return {
+        present: true,
+        valid: false,
+        profiles: {},
+        sessionStart: {},
+        error: invalid(
+          source,
+          "unsupported_key",
+          `${source} cognitiveRouting.profiles contains unsupported profile: ${unsupportedProfile}`,
+        ),
+      };
+    }
+
+    for (const name of COGNITIVE_ROUTING_PROFILE_NAMES) {
+      if (!Object.hasOwn(value.profiles, name)) continue;
+      const parsed = parseProfile(value.profiles[name], source, name);
+      if (parsed.error) {
+        return { present: true, valid: false, enabled, profiles: {}, sessionStart: {}, error: parsed.error };
+      }
+      profiles[name] = parsed.profile;
+    }
+  }
+
+  return { present: true, valid: true, enabled, profiles, sessionStart };
+}
+
+export function resolveCognitiveRoutingConfig(
+  repositoryConfig: unknown,
+  personalConfig: unknown,
+): CognitiveRoutingConfigResolution {
+  const repositoryValue = isRecord(repositoryConfig) ? repositoryConfig.cognitiveRouting : undefined;
+  const personalValue = isRecord(personalConfig) ? personalConfig.cognitiveRouting : undefined;
+  const repository = parseLayer(repositoryValue, "repository");
+  const personal = parseLayer(personalValue, "personal");
+  const configured = repository.present || personal.present;
+
+  const profiles: Partial<Record<CognitiveRoutingProfileName, CognitiveRoutingProfile>> = {};
+  const profileSources: Partial<Record<CognitiveRoutingProfileName, CognitiveRoutingConfigSource>> = {};
+  for (const name of COGNITIVE_ROUTING_PROFILE_NAMES) {
+    if (repository.profiles[name]) {
+      profiles[name] = repository.profiles[name];
+      profileSources[name] = "repository";
+    }
+    if (personal.profiles[name]) {
+      profiles[name] = personal.profiles[name];
+      profileSources[name] = "personal";
+    }
+  }
+
+  const enabled = personal.enabled ?? repository.enabled ?? false;
+  let enabledSource: CognitiveRoutingConfigSource = "default";
+  if (repository.enabled !== undefined) enabledSource = "repository";
+  if (personal.enabled !== undefined) enabledSource = "personal";
+
+  const sessionStartControl =
+    personal.sessionStart.control ?? repository.sessionStart.control ?? DEFAULT_COGNITIVE_ROUTING_SESSION_START.control;
+  const configuredSessionStartProfile =
+    personal.sessionStart.profile ?? repository.sessionStart.profile ?? DEFAULT_COGNITIVE_ROUTING_SESSION_START.profile;
+  const sessionStart: CognitiveRoutingSessionStart = {
+    control: sessionStartControl,
+    profile: sessionStartControl === "automatic" ? "reasoning" : configuredSessionStartProfile,
+  };
+  let sessionStartControlSource: CognitiveRoutingConfigSource = "default";
+  if (repository.sessionStart.control !== undefined) sessionStartControlSource = "repository";
+  if (personal.sessionStart.control !== undefined) sessionStartControlSource = "personal";
+  let sessionStartProfileSource: CognitiveRoutingConfigSource = "default";
+  if (sessionStartControl === "manual") {
+    if (repository.sessionStart.profile !== undefined) sessionStartProfileSource = "repository";
+    if (personal.sessionStart.profile !== undefined) sessionStartProfileSource = "personal";
+  }
+  const sessionStartSources = {
+    control: sessionStartControlSource,
+    profile: sessionStartProfileSource,
+  };
+  const error = repository.error ?? personal.error;
+
+  return {
+    configured,
+    valid: repository.valid && personal.valid,
+    enabled,
+    enabledSource,
+    profiles,
+    profileSources,
+    sessionStart,
+    sessionStartSources,
+    ...(error ? { error } : {}),
+  };
+}