@gonrocca/nodd 0.1.1 → 0.2.0

package/src/models/profiles.test.ts

@@ -7,6 +7,7 @@ import {
   mirrorToActiveProfile,
   readActiveProfile,
   readProfiles,
+  readThinking,
 } from "./profiles.ts";
 
 const withProfiles = () => ({
@@ -184,3 +185,88 @@ test("mirroring with no active profile changes nothing", () => {
   const data = { models: { implement: "anthropic/x" }, profiles: {}, activeProfile: null };
   assert.deepEqual(mirrorToActiveProfile(data), data);
 });
+
+// ---------------------------------------------------------------------------
+// Thinking levels travel with the models, and only when they exist
+// ---------------------------------------------------------------------------
+test("a profile reads back the thinking levels it was stored with", () => {
+  const result = readProfiles({
+    profiles: { fast: { models: { implement: "anthropic/x" }, thinking: { implement: "high" } } },
+  });
+  assert.deepEqual(result.profiles.fast, {
+    models: { implement: "anthropic/x" },
+    thinking: { implement: "high" },
+  });
+  assert.deepEqual(result.defects, []);
+});
+
+test("an invalid level is dropped and reported, not written on to frontmatter pi cannot resolve", () => {
+  const result = readProfiles({
+    profiles: { fast: { models: {}, thinking: { implement: "ultracode", explore: "high" } } },
+  });
+  assert.deepEqual(result.profiles.fast.thinking, { explore: "high" });
+  assert.ok(
+    result.defects.some((d) => d.includes("ultracode")),
+    `the discarded level must be named: ${JSON.stringify(result.defects)}`,
+  );
+});
+
+test("a profile with no levels carries no thinking key at all, so the file stays minimal", () => {
+  const result = readProfiles({ profiles: { fast: { models: { implement: "anthropic/x" } } } });
+  assert.deepEqual(result.profiles.fast, { models: { implement: "anthropic/x" } });
+  assert.ok(!("thinking" in result.profiles.fast), "an absent level set must not become an empty object");
+});
+
+test("new snapshots the live thinking map into the profile", () => {
+  const result = applyProfileCommand(
+    { models: { implement: "anthropic/x" }, thinking: { implement: "xhigh" } },
+    { kind: "new", name: "fresh" },
+  );
+  assert.equal(result.ok, true);
+  if (result.ok !== true) return;
+  assert.deepEqual(result.data.profiles, {
+    fresh: { models: { implement: "anthropic/x" }, thinking: { implement: "xhigh" } },
+  });
+});
+
+test("use applies the profile's levels to the live config, and clears them when it has none", () => {
+  const withLevels = applyProfileCommand(
+    { profiles: { fast: { models: { implement: "anthropic/x" }, thinking: { implement: "low" } } } },
+    { kind: "use", name: "fast" },
+  );
+  assert.equal(withLevels.ok, true);
+  if (withLevels.ok !== true) return;
+  assert.deepEqual(withLevels.data.thinking, { implement: "low" });
+
+  // A profile with no levels must not leave the previous profile's levels
+  // applied to its models: that would run a model at an effort nobody chose.
+  const without = applyProfileCommand(
+    { thinking: { implement: "low" }, profiles: { plain: { models: { implement: "anthropic/y" } } } },
+    { kind: "use", name: "plain" },
+  );
+  assert.equal(without.ok, true);
+  if (without.ok !== true) return;
+  assert.ok(!("thinking" in without.data), "the stale level set must be dropped, not carried over");
+});
+
+test("mirroring carries the live levels into the active profile", () => {
+  const mirrored = mirrorToActiveProfile({
+    models: { implement: "anthropic/just-edited" },
+    thinking: { implement: "medium" },
+    profiles: { fast: { models: { implement: "anthropic/old" } } },
+    activeProfile: "fast",
+  });
+  assert.deepEqual((mirrored.profiles as Record<string, unknown>).fast, {
+    models: { implement: "anthropic/just-edited" },
+    thinking: { implement: "medium" },
+  });
+});
+
+test("readThinking keeps only real levels, so a hand-edited file cannot inject one", () => {
+  assert.deepEqual(readThinking({ thinking: { implement: "high", explore: "max", track: "low" } }), {
+    implement: "high",
+    track: "low",
+  });
+  assert.deepEqual(readThinking({}), {});
+  assert.deepEqual(readThinking({ thinking: "broken" }), {});
+});

package/src/models/profiles.ts

@@ -13,7 +13,17 @@
 // leave the user staring at a profile that vanished with no explanation, and
 // throwing would take the whole command down over a hand-edit.
 
-export type Profile = { models: Record<string, string> };
+import { isThinkingLevel, type SlotThinking } from "./thinking.ts";
+
+/**
+ * A named set of slot assignments, plus the thinking level each one runs at.
+ *
+ * `thinking` is optional and omitted when empty, never stored as `{}`: the
+ * stored file is what the round-trip tests compare, and an empty object would
+ * make "this profile sets no levels" and "this profile sets levels, none of them"
+ * the same shape on disk.
+ */
+export type Profile = { models: Record<string, string>; thinking?: SlotThinking };
 
 /** Sub-command verbs, which therefore cannot be profile names. */
 export const RESERVED_PROFILE_NAMES = ["list", "new", "save", "use", "delete", "rm", "from"] as const;
@@ -45,6 +55,38 @@ function stringMap(value: unknown): Record<string, string> {
   return out;
 }
 
+/** The real levels inside one `thinking` map, dropping everything else. */
+function levelMap(value: unknown): SlotThinking {
+  const out: SlotThinking = {};
+  for (const [slot, level] of Object.entries(isObject(value) ? value : {})) {
+    if (isThinkingLevel(level)) out[slot] = level;
+  }
+  return out;
+}
+
+/**
+ * The thinking levels of a config object, keeping only real pi effort levels.
+ *
+ * A level pi cannot resolve is dropped rather than carried: it would reach
+ * `nodd-agents.ts` and land in agent frontmatter, failing at the moment the
+ * agent is launched instead of here, where the user can still see why.
+ */
+export function readThinking(data: Record<string, unknown>): SlotThinking {
+  return levelMap(data.thinking);
+}
+
+/** Every non-level found under a `thinking` map, for reporting. */
+function badLevels(value: unknown): string[] {
+  return Object.entries(isObject(value) ? value : {})
+    .filter(([, level]) => !isThinkingLevel(level))
+    .map(([slot, level]) => `${slot}=${String(level)}`);
+}
+
+/** A profile, with `thinking` present only when it holds something. */
+function profileOf(models: Record<string, string>, thinking: SlotThinking): Profile {
+  return Object.keys(thinking).length > 0 ? { models, thinking } : { models };
+}
+
 export type ReadProfiles = { profiles: Record<string, Profile>; defects: string[] };
 
 export function readProfiles(data: Record<string, unknown>): ReadProfiles {
@@ -65,7 +107,11 @@ export function readProfiles(data: Record<string, unknown>): ReadProfiles {
       defects.push(`profile \`${name}\` is not an object and was discarded`);
       continue;
     }
-    profiles[name] = { models: stringMap(value.models) };
+    const bad = badLevels(value.thinking);
+    if (bad.length > 0) {
+      defects.push(`profile \`${name}\` has thinking levels pi cannot resolve, discarded: ${bad.join(", ")}`);
+    }
+    profiles[name] = profileOf(stringMap(value.models), levelMap(value.thinking));
   }
   return { profiles, defects };
 }
@@ -79,7 +125,22 @@ export function readActiveProfile(data: Record<string, unknown>): string | null
 
 /** The flat config as a profile snapshot. */
 function snapshot(data: Record<string, unknown>): Profile {
-  return { models: stringMap(data.models) };
+  return profileOf(stringMap(data.models), readThinking(data));
+}
+
+/**
+ * Apply a profile's models and levels to the flat config.
+ *
+ * A profile with no levels *removes* the key rather than leaving the previous
+ * profile's levels behind: a stale level would keep running a model at an effort
+ * nobody chose for it, which is the silent-divergence defect this whole command
+ * is built to avoid.
+ */
+function flatten(data: Record<string, unknown>, profile: Profile): Record<string, unknown> {
+  const next: Record<string, unknown> = { ...data, models: { ...profile.models } };
+  if (profile.thinking) next.thinking = { ...profile.thinking };
+  else delete next.thinking;
+  return next;
 }
 
 /**
@@ -138,7 +199,7 @@ export function applyProfileCommand(data: Record<string, unknown>, command: Prof
     }
     return {
       ok: true,
-      data: { ...data, models: { ...profile.models }, activeProfile: command.name },
+      data: { ...flatten(data, profile), activeProfile: command.name },
       message: `perfil ${command.name} activado`,
     };
   }

package/src/models/slots.ts

@@ -22,8 +22,9 @@ export const MECHANISM_PLACEHOLDER = "mecanismo · sin modelo";
 
 const GLOBAL_SLOTS = ["default", "orchestrator"] as const;
 
-function isMechanism(step: string): boolean {
-  return (MECHANISM_STEPS as readonly string[]).includes(step);
+/** A canonical step NODD implements as mechanism, so it gets no slot. */
+export function isMechanismSlot(id: string): boolean {
+  return (MECHANISM_STEPS as readonly string[]).includes(id);
 }
 
 /**
@@ -33,7 +34,7 @@ function isMechanism(step: string): boolean {
 export const SLOT_ROWS: readonly SlotRow[] = Object.freeze([
   ...GLOBAL_SLOTS.map((id): SlotRow => ({ id, kind: "global", placeholder: "sin asignar" })),
   ...CANONICAL_STEPS.map((id): SlotRow =>
-    isMechanism(id)
+    isMechanismSlot(id)
       ? { id, kind: "mechanism", placeholder: MECHANISM_PLACEHOLDER }
       : { id, kind: "step", placeholder: "sin asignar" },
   ),

package/src/models/thinking.test.ts

@@ -0,0 +1,14 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { THINKING_LEVELS, isThinkingLevel } from "./thinking.ts";
+
+test("the six real pi effort levels are listed in ascending order", () => {
+  assert.deepEqual([...THINKING_LEVELS], ["off", "minimal", "low", "medium", "high", "xhigh"]);
+});
+
+test("only a real level is a level: no max, no ultracode, no casing games", () => {
+  for (const level of THINKING_LEVELS) assert.equal(isThinkingLevel(level), true);
+  for (const bad of ["max", "ultracode", "HIGH", "", "extreme", 3, null, undefined, {}]) {
+    assert.equal(isThinkingLevel(bad), false, `${JSON.stringify(bad)} is not a pi effort level`);
+  }
+});

package/src/models/thinking.ts

@@ -0,0 +1,22 @@
+// The thinking level of a slot: pi's reasoning effort, per configured model.
+//
+// Adapted from `zero-models.ts:84-93`. These six strings are the real pi effort
+// levels and the only source of truth for validity here — `max` and `ultracode`
+// are not levels, and a config that names one is rejected rather than passed
+// through to frontmatter pi cannot resolve.
+//
+// The level is not decoration: `extensions/nodd-agents.ts` emits it as the
+// `thinking:` line of every generated agent file, which is what makes choosing
+// one in the picker mean something.
+
+/** The six real pi effort levels, ascending. */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
+/** slot -> level. Partial on purpose: an absent slot means no level configured. */
+export type SlotThinking = Record<string, ThinkingLevel>;
+
+export function isThinkingLevel(value: unknown): value is ThinkingLevel {
+  return typeof value === "string" && (THINKING_LEVELS as readonly string[]).includes(value);
+}