@hassangameryt/freeflow 0.7.1 → 0.7.2

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

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

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