@hassangameryt/freeflow 0.4.0 → 0.6.0

package/pi-extension/dist/cognitive-routing/commands.js

@@ -0,0 +1,96 @@
+const PROFILE_VALUES = ["standard", "reasoning", "auto"];
+const HISTORY_VALUES = ["history", "history active", "history anomalies"];
+export function cognitiveRoutingProfileCompletions(prefix) {
+  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 without changing the model"
+          : 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) {
+  if (value === "history") return {};
+  if (value === "history active") return { scope: "active-branch" };
+  if (value === "history anomalies") return { anomaliesOnly: true };
+  return undefined;
+}
+function formatHistory(result) {
+  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, ctx, controller) {
+  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
+        ? 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)) {
+    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 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);
+  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/dist/cognitive-routing/config.js

@@ -0,0 +1,236 @@
+import {
+  COGNITIVE_ROUTING_PROFILE_NAMES,
+  COGNITIVE_ROUTING_SESSION_START_CONTROLS,
+  DEFAULT_COGNITIVE_ROUTING_SESSION_START,
+} from "./types.js";
+const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const PROFILE_NAME_SET = new Set(COGNITIVE_ROUTING_PROFILE_NAMES);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalid(source, code, message, profile) {
+  return { code, message, ...(profile ? { profile } : {}), source };
+}
+function parseProfile(value, source, name) {
+  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)) {
+    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,
+    },
+  };
+}
+function parseSessionStart(value, source) {
+  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;
+  if (Object.hasOwn(value, "control")) {
+    if (typeof value.control !== "string" || !COGNITIVE_ROUTING_SESSION_START_CONTROLS.includes(value.control)) {
+      return {
+        error: invalid(
+          source,
+          "invalid_session_start",
+          `${source} cognitiveRouting.sessionStart.control must be automatic or manual`,
+        ),
+      };
+    }
+    control = value.control;
+  }
+  let profile;
+  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;
+  }
+  return { sessionStart: { ...(control ? { control } : {}), ...(profile ? { profile } : {}) } };
+}
+function parseLayer(value, source) {
+  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;
+  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 = {};
+  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 = {};
+  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, personalConfig) {
+  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 = {};
+  const profileSources = {};
+  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 = "default";
+  if (repository.enabled !== undefined) enabledSource = "repository";
+  if (personal.enabled !== undefined) enabledSource = "personal";
+  const sessionStart = {
+    control:
+      personal.sessionStart.control ??
+      repository.sessionStart.control ??
+      DEFAULT_COGNITIVE_ROUTING_SESSION_START.control,
+    profile:
+      personal.sessionStart.profile ??
+      repository.sessionStart.profile ??
+      DEFAULT_COGNITIVE_ROUTING_SESSION_START.profile,
+  };
+  const sessionStartSources = {
+    control:
+      personal.sessionStart.control !== undefined
+        ? "personal"
+        : repository.sessionStart.control !== undefined
+          ? "repository"
+          : "default",
+    profile:
+      personal.sessionStart.profile !== undefined
+        ? "personal"
+        : repository.sessionStart.profile !== undefined
+          ? "repository"
+          : "default",
+  };
+  const error = repository.error ?? personal.error;
+  return {
+    configured,
+    valid: repository.valid && personal.valid,
+    enabled,
+    enabledSource,
+    profiles,
+    profileSources,
+    sessionStart,
+    sessionStartSources,
+    ...(error ? { error } : {}),
+  };
+}