@hassangameryt/freeflow 0.7.0 → 0.7.2

package/pi-extension/dist/cognitive-routing/pi-session-control.js

@@ -1,320 +0,0 @@
-export const PI_SESSION_MODEL_STATE_ENTRY = "freeflow-cognitive-routing-model-state";
-export function supportsPiSessionModelStateApi(pi) {
-  if (!pi || typeof pi !== "object") return false;
-  const candidate = pi;
-  return (
-    typeof candidate.appendEntry === "function" &&
-    typeof candidate.setModel === "function" &&
-    typeof candidate.setThinkingLevel === "function"
-  );
-}
-const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function isThinkingLevel(value) {
-  return typeof value === "string" && THINKING_LEVELS.has(value);
-}
-function appendModelStateCommit(pi, commit) {
-  try {
-    pi.appendEntry(PI_SESSION_MODEL_STATE_ENTRY, commit);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function pairFrom(value) {
-  if (!isRecord(value)) return undefined;
-  if (
-    typeof value.provider !== "string" ||
-    typeof value.modelId !== "string" ||
-    !isThinkingLevel(value.thinkingLevel)
-  ) {
-    return undefined;
-  }
-  return {
-    provider: value.provider,
-    modelId: value.modelId,
-    thinkingLevel: value.thinkingLevel,
-  };
-}
-function failureFrom(value) {
-  if (
-    value === "model-change-failed" ||
-    value === "thinking-level-change-failed" ||
-    value === "pair-verification-failed" ||
-    value === "rollback-failed" ||
-    value === "commit-persistence-failed" ||
-    value === "interrupted-transition"
-  ) {
-    return value;
-  }
-  return undefined;
-}
-function originFrom(value) {
-  if (!isRecord(value)) return undefined;
-  if (value.source !== "pi" || value.operation !== "session-model-state-control") return undefined;
-  return { source: "pi", operation: "session-model-state-control" };
-}
-export function parsePiSessionModelStateCommit(value) {
-  if (!isRecord(value) || value.version !== 1) return undefined;
-  if (value.phase !== "prepared" && value.phase !== "committed" && value.phase !== "aborted") return undefined;
-  if (
-    value.status !== "prepared" &&
-    value.status !== "applied" &&
-    value.status !== "rolled-back" &&
-    value.status !== "rollback-failed"
-  ) {
-    return undefined;
-  }
-  if (typeof value.correlationId !== "string") return undefined;
-  const fromPair = pairFrom(value.fromPair);
-  const target = pairFrom(value.target);
-  const origin = originFrom(value.origin);
-  if (!fromPair || !target || !origin) return undefined;
-  if (value.phase === "prepared" && value.status !== "prepared") return undefined;
-  if (value.phase === "committed" && value.status !== "applied") return undefined;
-  if (value.phase === "aborted" && (value.status === "prepared" || value.status === "applied")) return undefined;
-  const failure = failureFrom(value.failure);
-  if ((value.phase === "prepared" || value.phase === "committed") && value.failure !== undefined) return undefined;
-  if (value.phase === "aborted" && !failure) return undefined;
-  let observedPair;
-  if (value.observedPair !== undefined) {
-    observedPair = pairFrom(value.observedPair);
-    if (!observedPair) return undefined;
-  }
-  return {
-    version: 1,
-    phase: value.phase,
-    status: value.status,
-    correlationId: value.correlationId,
-    fromPair,
-    target,
-    ...(failure ? { failure } : {}),
-    ...(observedPair ? { observedPair } : {}),
-    origin,
-  };
-}
-function currentPair(ctx) {
-  const model = ctx.model;
-  if (!model || typeof model.provider !== "string" || typeof model.id !== "string") return undefined;
-  if (!ctx.thinkingLevel) return undefined;
-  return {
-    provider: model.provider,
-    modelId: model.id,
-    thinkingLevel: ctx.thinkingLevel,
-  };
-}
-function pairsEqual(left, right) {
-  return (
-    left?.provider === right.provider && left.modelId === right.modelId && left.thinkingLevel === right.thinkingLevel
-  );
-}
-async function restorePair(pi, ctx, pair) {
-  const model = ctx.modelRegistry?.find(pair.provider, pair.modelId);
-  if (!model) return false;
-  try {
-    if (!(await pi.setModel(model))) return false;
-    pi.setThinkingLevel(pair.thinkingLevel);
-    return pairsEqual(currentPair(ctx), pair);
-  } catch {
-    return false;
-  }
-}
-export function createPiSessionControllerHost({ pi, ctx }) {
-  const control = createPiSessionModelStateControl({ pi, ctx });
-  return {
-    appendEntryDurable(customType, data) {
-      pi.appendEntry(customType, data);
-    },
-    acquireModelStateControl: control.acquireModelStateControl,
-    recoverPreparedModelState: control.recoverPreparedModelState,
-  };
-}
-export function createPiSessionModelStateControl({ pi, ctx }) {
-  let owner;
-  return {
-    async recoverPreparedModelState({ fromPair, target, correlationId }) {
-      const current = currentPair(ctx);
-      if (!current || !pairsEqual(current, fromPair)) {
-        if (!(await restorePair(pi, ctx, fromPair))) {
-          const rollbackFailed = {
-            version: 1,
-            phase: "aborted",
-            status: "rollback-failed",
-            correlationId,
-            fromPair,
-            target,
-            failure: "rollback-failed",
-            ...(currentPair(ctx) ? { observedPair: currentPair(ctx) } : {}),
-            origin: { source: "pi", operation: "session-model-state-control" },
-          };
-          try {
-            pi.appendEntry(PI_SESSION_MODEL_STATE_ENTRY, rollbackFailed);
-          } catch {
-            return { status: "rejected" };
-          }
-          return { status: "rollback-failed" };
-        }
-      }
-      const aborted = {
-        version: 1,
-        phase: "aborted",
-        status: "rolled-back",
-        correlationId,
-        fromPair,
-        target,
-        failure: "interrupted-transition",
-        origin: { source: "pi", operation: "session-model-state-control" },
-      };
-      try {
-        pi.appendEntry(PI_SESSION_MODEL_STATE_ENTRY, aborted);
-      } catch {
-        return { status: "rejected" };
-      }
-      return { status: "restored" };
-    },
-    async acquireModelStateControl({ label }) {
-      if (owner !== undefined) return { status: "conflict", owner };
-      owner = label;
-      let released = false;
-      return {
-        status: "acquired",
-        lease: {
-          async setState(request) {
-            if (released) return { status: "rejected" };
-            const fromPair = currentPair(ctx);
-            const targetModel = ctx.modelRegistry?.find(request.provider, request.modelId);
-            if (!fromPair || !targetModel) return { status: "rejected" };
-            const target = {
-              provider: request.provider,
-              modelId: request.modelId,
-              thinkingLevel: request.thinkingLevel,
-            };
-            const prepared = {
-              version: 1,
-              phase: "prepared",
-              status: "prepared",
-              correlationId: request.correlationId,
-              fromPair,
-              target,
-              origin: { source: "pi", operation: "session-model-state-control" },
-            };
-            try {
-              pi.appendEntry(PI_SESSION_MODEL_STATE_ENTRY, prepared);
-            } catch {
-              return { status: "rejected" };
-            }
-            let failure;
-            try {
-              const applied = await pi.setModel(targetModel);
-              if (!applied) {
-                const aborted = {
-                  version: 1,
-                  phase: "aborted",
-                  status: "rolled-back",
-                  correlationId: request.correlationId,
-                  fromPair,
-                  target,
-                  failure: "model-change-failed",
-                  origin: { source: "pi", operation: "session-model-state-control" },
-                };
-                appendModelStateCommit(pi, aborted);
-                return { status: "rejected" };
-              }
-              try {
-                pi.setThinkingLevel(request.thinkingLevel);
-              } catch {
-                failure = "thinking-level-change-failed";
-              }
-              if (!failure && !pairsEqual(currentPair(ctx), target)) {
-                failure = "pair-verification-failed";
-              }
-            } catch {
-              failure = "model-change-failed";
-            }
-            if (failure) {
-              const restored = await restorePair(pi, ctx, fromPair);
-              if (!restored) {
-                const rollbackFailed = {
-                  version: 1,
-                  phase: "aborted",
-                  status: "rollback-failed",
-                  correlationId: request.correlationId,
-                  fromPair,
-                  target,
-                  failure: "rollback-failed",
-                  ...(currentPair(ctx) ? { observedPair: currentPair(ctx) } : {}),
-                  origin: { source: "pi", operation: "session-model-state-control" },
-                };
-                appendModelStateCommit(pi, rollbackFailed);
-                return { status: "rejected" };
-              }
-              const aborted = {
-                version: 1,
-                phase: "aborted",
-                status: "rolled-back",
-                correlationId: request.correlationId,
-                fromPair,
-                target,
-                failure,
-                origin: { source: "pi", operation: "session-model-state-control" },
-              };
-              appendModelStateCommit(pi, aborted);
-              return { status: "rejected" };
-            }
-            const commit = {
-              version: 1,
-              phase: "committed",
-              status: "applied",
-              correlationId: request.correlationId,
-              fromPair,
-              target,
-              origin: { source: "pi", operation: "session-model-state-control" },
-            };
-            try {
-              if (!appendModelStateCommit(pi, commit)) throw new Error("commit persistence failed");
-              return { status: "applied" };
-            } catch {
-              const restored = await restorePair(pi, ctx, fromPair);
-              if (!restored) {
-                const rollbackFailed = {
-                  version: 1,
-                  phase: "aborted",
-                  status: "rollback-failed",
-                  correlationId: request.correlationId,
-                  fromPair,
-                  target,
-                  failure: "rollback-failed",
-                  ...(currentPair(ctx) ? { observedPair: currentPair(ctx) } : {}),
-                  origin: { source: "pi", operation: "session-model-state-control" },
-                };
-                appendModelStateCommit(pi, rollbackFailed);
-                return { status: "rejected" };
-              }
-              const aborted = {
-                version: 1,
-                phase: "aborted",
-                status: "rolled-back",
-                correlationId: request.correlationId,
-                fromPair,
-                target,
-                failure: "commit-persistence-failed",
-                origin: { source: "pi", operation: "session-model-state-control" },
-              };
-              appendModelStateCommit(pi, aborted);
-              return { status: "rejected" };
-            }
-          },
-          async release() {
-            if (!released) {
-              released = true;
-              if (owner === label) owner = undefined;
-            }
-            return { status: "released" };
-          },
-        },
-      };
-    },
-  };
-}

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

@@ -1,43 +0,0 @@
-import { resolveCognitiveRoutingConfig } from "./config.js";
-import { preflightCognitiveRoutingProfiles } from "./host.js";
-function blockingReason(code, message) {
-  return { code, message };
-}
-function baseState(config) {
-  return {
-    configured: config.configured,
-    configValid: config.valid,
-    enabled: config.enabled,
-    effective: false,
-    enabledSource: config.enabledSource,
-    profiles: config.profiles,
-    profileSources: config.profileSources,
-    sessionStart: config.sessionStart,
-    sessionStartSources: config.sessionStartSources,
-    resolvedProfiles: {},
-    blockingReason: blockingReason("disabled", "Cognitive Routing is disabled"),
-  };
-}
-export async function resolveCognitiveRoutingState(repositoryConfig, personalConfig, host) {
-  const config = resolveCognitiveRoutingConfig(repositoryConfig, personalConfig);
-  const state = baseState(config);
-  if (!config.valid) {
-    return {
-      ...state,
-      blockingReason: blockingReason(
-        "config_invalid",
-        config.error?.message ?? "Cognitive Routing configuration is invalid",
-      ),
-    };
-  }
-  if (!config.enabled) {
-    return state;
-  }
-  const preflight = await preflightCognitiveRoutingProfiles(config, host);
-  return {
-    ...state,
-    effective: preflight.effective,
-    resolvedProfiles: preflight.resolvedProfiles,
-    blockingReason: preflight.blockingReason ?? blockingReason("disabled", "Cognitive Routing is not effective"),
-  };
-}

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

@@ -1,212 +0,0 @@
-import { textComponent } from "../ui/text-component.js";
-export const COGNITIVE_ROUTING_SWITCH_TOOL_NAME = "freeflow_switch_profile";
-export const COGNITIVE_ROUTING_HISTORY_TOOL_NAME = "freeflow_cognitive_routing_history";
-export const COGNITIVE_ROUTING_HISTORY_PARAMETERS = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    scope: {
-      type: "string",
-      enum: ["session", "active-branch"],
-      description: "History scope to read.",
-    },
-    anomaliesOnly: {
-      type: "boolean",
-      description: "Return only events whose integrity is anomaly.",
-    },
-    limit: {
-      type: "integer",
-      minimum: 1,
-      maximum: 100,
-      description: "Maximum number of newest events to return.",
-    },
-  },
-  required: [],
-};
-export const COGNITIVE_ROUTING_SWITCH_PARAMETERS = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    target: {
-      type: "string",
-      enum: ["standard", "reasoning"],
-      description: "The configured Cognitive Routing profile to activate.",
-    },
-    reason: {
-      type: "string",
-      minLength: 1,
-      maxLength: 160,
-      description: "A concise one-line reason for the profile transition.",
-    },
-  },
-  required: ["target", "reason"],
-};
-function resultText(result) {
-  if (result.status === "active") {
-    const fields = [COGNITIVE_ROUTING_SWITCH_TOOL_NAME + "|active", `profile|${result.profile}`];
-    if (result.changed !== undefined) fields.push(`changed|${result.changed}`);
-    if (result.from) fields.push(`from|${result.from}`);
-    if (result.to) fields.push(`to|${result.to}`);
-    return fields.join("\n");
-  }
-  return `${COGNITIVE_ROUTING_SWITCH_TOOL_NAME}|${result.status}\nreason|${result.reason}`;
-}
-function blocked(reason) {
-  return { status: "blocked", reason };
-}
-function renderNothing() {
-  return {
-    render() {
-      return [];
-    },
-    invalidate() {},
-  };
-}
-function renderTransition(text, theme) {
-  return textComponent(theme?.fg ? theme.fg("accent", text) : text);
-}
-function isProfileName(value) {
-  return value === "standard" || value === "reasoning";
-}
-function resultFromPayload(payload) {
-  const details = payload?.details?.result ?? payload?.result ?? payload?.details;
-  if (details && (details.status === "active" || details.status === "blocked" || details.status === "inactive")) {
-    if (details.status !== "active") return details;
-    if (!isProfileName(details.profile)) return undefined;
-    return {
-      status: "active",
-      profile: details.profile,
-      ...(typeof details.changed === "boolean" ? { changed: details.changed } : {}),
-      ...(isProfileName(details.from) ? { from: details.from } : {}),
-      ...(isProfileName(details.to) ? { to: details.to } : {}),
-    };
-  }
-  const text = Array.isArray(payload?.content)
-    ? payload.content.find((part) => part?.type === "text")?.text
-    : undefined;
-  if (typeof text !== "string") return undefined;
-  const fields = new Map();
-  for (const line of text.split("\\n")) {
-    const separator = line.indexOf("|");
-    if (separator <= 0) continue;
-    fields.set(line.slice(0, separator), line.slice(separator + 1));
-  }
-  const status = fields.get(COGNITIVE_ROUTING_SWITCH_TOOL_NAME);
-  if (status === "active") {
-    const profile = fields.get("profile");
-    if (!isProfileName(profile)) return undefined;
-    const changed = fields.get("changed");
-    const from = fields.get("from");
-    const to = fields.get("to");
-    return {
-      status,
-      profile,
-      ...(changed === "true" || changed === "false" ? { changed: changed === "true" } : {}),
-      ...(isProfileName(from) ? { from } : {}),
-      ...(isProfileName(to) ? { to } : {}),
-    };
-  }
-  if (status === "blocked" || status === "inactive") {
-    const reason = fields.get("reason");
-    return reason ? { status, reason } : undefined;
-  }
-  return undefined;
-}
-function historyOptions(params) {
-  return {
-    ...(params.scope === "active-branch" ? { scope: "active-branch" } : {}),
-    ...(params.anomaliesOnly === true ? { anomaliesOnly: true } : {}),
-    ...(Number.isInteger(params.limit) ? { limit: Math.max(1, Math.min(100, params.limit)) } : {}),
-  };
-}
-function validateParams(params) {
-  if (params.target !== "standard" && params.target !== "reasoning") {
-    return { status: "invalid", reason: "target_must_be_standard_or_reasoning" };
-  }
-  if (typeof params.reason !== "string") {
-    return { status: "invalid", reason: "reason_required" };
-  }
-  const reason = params.reason.trim();
-  if (!reason) return { status: "invalid", reason: "reason_required" };
-  if (reason.includes("\n") || reason.includes("\r"))
-    return { status: "invalid", reason: "reason_must_be_single_line" };
-  if (reason.length > 160) return { status: "invalid", reason: "reason_too_long" };
-  return { status: "valid", target: params.target, reason };
-}
-export function registerCognitiveRoutingTool(pi, getController) {
-  pi.registerTool({
-    name: COGNITIVE_ROUTING_SWITCH_TOOL_NAME,
-    label: "Switch Cognitive Profile",
-    description: "Request one bounded Cognitive Routing profile transition while automatic control is active.",
-    promptSnippet: "Switch between the configured standard and reasoning profiles when the current task needs it.",
-    promptGuidelines: [
-      "Use only when the current task needs a different reasoning profile.",
-      "Give one concise sentence as the reason and make this the only tool call in the response.",
-      "Do not call this tool while a deterministic manual profile hold is active.",
-    ],
-    parameters: COGNITIVE_ROUTING_SWITCH_PARAMETERS,
-    executionMode: "sequential",
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const controller = getController();
-      const input = validateParams(params ?? {});
-      let result;
-      if (input.status === "invalid") {
-        result = blocked(input.reason);
-      } else if (!controller) {
-        result = blocked("not_available");
-      } else if (!controller.state().effective) {
-        result = blocked("not_active");
-      } else if (controller.state().controlMode === "automatic") {
-        result = await controller.switchAutomaticProfile(input.target, input.reason);
-      } else {
-        result = blocked("manual_hold");
-      }
-      return {
-        content: [{ type: "text", text: resultText(result) }],
-        details: { result },
-      };
-    },
-    renderCall(_args, _theme) {
-      return renderNothing();
-    },
-    renderResult(result, _options, theme) {
-      const outcome = resultFromPayload(result);
-      if (outcome?.status === "active") {
-        if (outcome.changed === true && outcome.from && outcome.to) {
-          return renderTransition(`Cognitive Routing: ${outcome.from} → ${outcome.to}`, theme);
-        }
-        if (outcome.changed === false && outcome.to) {
-          return renderTransition(`Cognitive Routing: ${outcome.to} (already active)`, theme);
-        }
-        return renderTransition(`Cognitive Routing: active · ${outcome.profile}`, theme);
-      }
-      if (outcome) {
-        return renderTransition(`Cognitive Routing: ${outcome.status} · ${outcome.reason}`, theme);
-      }
-      return renderTransition(`Cognitive Routing: ${result?.isError ? "error" : "result unavailable"}`, theme);
-    },
-  });
-}
-export function registerCognitiveRoutingHistoryTool(pi, readHistory) {
-  pi.registerTool({
-    name: COGNITIVE_ROUTING_HISTORY_TOOL_NAME,
-    label: "Read Cognitive Routing History",
-    description:
-      "Read the deterministic Cognitive Routing transition history without changing routing or session state.",
-    promptSnippet: "Inspect Cognitive Routing transition history when debugging or monitoring profile behavior.",
-    promptGuidelines: [
-      "Use only when debugging or monitoring Cognitive Routing is requested.",
-      "This tool is read-only and does not change profile, control, branch, or session state.",
-      "Use scope=active-branch to inspect only the current branch ancestry.",
-      "Use anomaliesOnly=true to inspect only integrity anomalies.",
-    ],
-    parameters: COGNITIVE_ROUTING_HISTORY_PARAMETERS,
-    async execute(_toolCallId, params, _signal, _onUpdate, context) {
-      const result = await readHistory(historyOptions(params ?? {}), context);
-      return {
-        content: [{ type: "text", text: `Cognitive Routing history\n${JSON.stringify(result)}` }],
-        details: { result },
-      };
-    },
-  });
-}

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

@@ -1,6 +0,0 @@
-export const COGNITIVE_ROUTING_PROFILE_NAMES = ["standard", "reasoning"];
-export const COGNITIVE_ROUTING_SESSION_START_CONTROLS = ["automatic", "manual"];
-export const DEFAULT_COGNITIVE_ROUTING_SESSION_START = {
-  control: "automatic",
-  profile: "reasoning",
-};