@hassangameryt/freeflow 0.5.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hassangameryt/freeflow",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Feedback-based control system for coding agents.",
   "publishConfig": {
     "access": "public"
@@ -18,24 +18,33 @@
   "scripts": {
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "format:router-dist": "prettier --write router/dist",
     "format:pi-extension-dist": "prettier --write pi-extension/dist",
-    "build:router": "tsc -p router/tsconfig.json && npm run format:router-dist",
     "build:pi-extension": "tsc -p pi-extension/tsconfig.json && npm run format:pi-extension-dist",
-    "build": "npm run build:router && npm run build:pi-extension",
+    "build": "npm run build:pi-extension",
+    "typecheck": "tsc -p pi-extension/tsconfig.json --noEmit",
+    "check": "npm run typecheck && npm run check:source && npm run check:changelog && npm run check:release-workflow && npm run check:docs && npm run format:check && npm run check:release-version && npm run check:commands && npm run check:activation && npm run check:runtime && npm run check:package",
+    "check:source": "node scripts/validation/check-source-files.mjs",
+    "check:changelog": "node scripts/validation/check-changelog.mjs --structure",
+    "check:release-workflow": "node scripts/validation/check-release-workflow.mjs",
+    "check:docs": "node scripts/validation/check-docs.mjs",
+    "check:release-version": "node scripts/validation/check-release-version.mjs",
+    "check:commands": "scripts/validation/audit-command-surface.sh",
+    "check:activation": "scripts/validation/check-activation-contract.sh",
+    "check:runtime": "hooks/tests/check-runtime-context-hook.sh",
+    "check:package": "node scripts/validation/check-package.mjs",
+    "check:release-metadata": "scripts/validation/validate-release-metadata.sh --mode prepublish",
     "test:pi-extension": "npm run build && node --test $(find pi-extension/tests -name '*.test.js' | sort)",
-    "test:router": "npm run build:router && node --test $(find router/tests -name '*.test.js' | sort)",
     "test:skill-author": "node --test $(find .skill-eval/write-skill/tests -name '*.test.mjs' | sort)",
     "test:skill-eval": "node --test $(find .skill-eval/evaluate-skill/tests -name '*.test.mjs' | sort)",
-    "bench:router": "npm run build:router && node router/dist/benchmarks/benchmarks.js",
-    "bench:router:commands": "npm run build:router && node router/dist/benchmarks/command-benchmarks.js",
-    "bench:router:context-saving-baseline": "npm run build:router && node router/dist/benchmarks/context-saving-baseline.js",
-    "bench:router:context-mode-normalized": "npm run build:router && node router/dist/benchmarks/context-mode-normalized-benchmarks.js",
-    "bench:router:context-mode-real-deep": "npm run build:router && node router/dist/benchmarks/context-mode-real-deep-benchmark.js",
-    "bench:router:storage-policy": "npm run build:router && node router/dist/benchmarks/storage-policy-benchmarks.js",
-    "bench:router:index": "npm run build:router && node router/dist/benchmarks/index-benchmarks.js",
-    "bench:router:vault-index": "npm run build:router && node router/dist/benchmarks/vault-index-benchmarks.js",
-    "bench:router:codex-qa": "npm run build:router && node router/dist/benchmarks/codex-qa-benchmarks.js"
+    "test:track-work": "node --test .skill-eval/track-work/tests/*.test.mjs",
+    "test:freeflow-snapshot": "node --test scripts/freeflow-snapshot.test.mjs",
+    "test:release-utils": "node --test scripts/release-utils.test.mjs",
+    "test:changelog": "node --test scripts/validation/check-changelog.test.mjs",
+    "test:release-workflow": "node --test scripts/validation/check-release-workflow.test.mjs",
+    "test:docs": "node --test scripts/validation/check-docs.test.mjs",
+    "release:prepare": "node scripts/release.mjs",
+    "release:notes": "node scripts/release-notes.mjs",
+    "snapshot:refresh": "node scripts/freeflow-snapshot.mjs"
   },
   "keywords": [
     "pi-package",
@@ -67,18 +76,19 @@
     "README.md",
     "assets/**",
     "capabilities/**",
+    "runtime/**",
     "command-surface.json",
     "hooks/**",
     "pi-extension/**",
-    "router/dist/**",
-    "runtime/**",
     "skills/**"
   ],
   "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-tui": "0.80.10",
+    "@earendil-works/pi-coding-agent": "0.84.4",
+    "@earendil-works/pi-tui": "0.84.4",
     "@types/node": "^22.15.30",
     "prettier": "3.9.5",
     "typescript": "^5.8.3"

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 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) {
+  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
+        ? 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)) {
+    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);
+  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,232 @@
+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 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 = {
+    control: sessionStartControl,
+    profile: sessionStartControl === "automatic" ? "reasoning" : configuredSessionStartProfile,
+  };
+  let sessionStartControlSource = "default";
+  if (repository.sessionStart.control !== undefined) sessionStartControlSource = "repository";
+  if (personal.sessionStart.control !== undefined) sessionStartControlSource = "personal";
+  let sessionStartProfileSource = "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 } : {}),
+  };
+}