infinity-harness 2.0.0

package/src/taskList.ts

@@ -0,0 +1,355 @@
+/**
+ * infinity-harness — the atomic plan editor.
+ *
+ * The agent edits the plan by submitting the *whole* task list. That sounds
+ * wasteful until you watch a model try to do incremental edits over a long
+ * run: it loses track of what exists, re-adds deleted tasks, and drifts from
+ * the file. Submitting the full list makes every write self-correcting, and
+ * makes omission mean deletion — a single unambiguous rule.
+ *
+ * Three invariants hold on every write:
+ *
+ *   1. `baseRevision` must match, or the write is rejected. Two workers
+ *      cannot silently clobber each other during a parallel run.
+ *   2. Unknown fields on a stored task survive. An update merges onto the
+ *      task on disk rather than replacing it, so `difficulty`, `modelHint`,
+ *      `criteria` and anything a later version adds are never dropped.
+ *   3. The dependency graph stays acyclic and every reference resolves.
+ */
+
+import type { FeatureList, Task, TaskStatus, Subtask } from "./core/types.ts";
+import { ValidationError } from "./core/types.ts";
+import {
+  MAX_TASKS,
+  MAX_DEPENDS_ON,
+  MAX_SUBJECT_LEN,
+  MAX_DESCRIPTION_LEN,
+  detectCycle,
+  flattenTasks,
+  loadFeatureList,
+  normalizeStatus,
+  normalizeSubtaskStatus,
+  saveFeatureList,
+  validateKey,
+  type FlatTask,
+} from "./core/featureList.ts";
+import { featureListPath } from "./core/paths.ts";
+import { withLockSync } from "./core/lock.ts";
+
+/** One task as submitted by the agent. Only `key` is mandatory. */
+export type TaskInput = {
+  key: string;
+  subject?: string;
+  description?: string;
+  status?: string;
+  dependsOn?: string[];
+  subtasks?: Array<{ title: string; status?: string }>;
+  difficulty?: string;
+  modelHint?: string;
+  criteria?: string[];
+};
+
+export type ApplyInput = {
+  baseRevision?: number;
+  tasks: TaskInput[];
+};
+
+export type Change = {
+  added: string[];
+  updated: string[];
+  removed: string[];
+  reordered: boolean;
+};
+
+export type ApplyResult = {
+  revision: number;
+  list: FeatureList;
+  tasks: FlatTask[];
+  change: Change;
+  /** False when the submission was a no-op; the revision did not move. */
+  changed: boolean;
+};
+
+const DEFAULT_FEATURE_ID = "feature-001";
+
+function splitKey(key: string): { featureId: string | null; taskId: string } {
+  const i = key.indexOf("/");
+  if (i === -1) return { featureId: null, taskId: key };
+  return { featureId: key.slice(0, i), taskId: key.slice(i + 1) };
+}
+
+function validateSubtasks(raw: TaskInput["subtasks"], path: string): Subtask[] {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((st, i) => {
+    const title = String(st?.title ?? "").trim();
+    if (!title) throw new ValidationError(`${path}.subtasks[${i}].title is required`);
+    if (title.length > MAX_SUBJECT_LEN) {
+      throw new ValidationError(`${path}.subtasks[${i}].title exceeds ${MAX_SUBJECT_LEN} characters`);
+    }
+    let status: Subtask["status"];
+    try {
+      status = normalizeSubtaskStatus(st?.status ?? "pending");
+    } catch {
+      throw new ValidationError(`${path}.subtasks[${i}].status is invalid: ${String(st?.status)}`);
+    }
+    return { id: `${path.replace(/\W+/g, "-")}-st${i}`, title, status };
+  });
+}
+
+function validateDependsOn(raw: string[] | undefined, path: string): string[] {
+  if (!Array.isArray(raw)) return [];
+  if (raw.length > MAX_DEPENDS_ON) {
+    throw new ValidationError(`${path}.dependsOn supports at most ${MAX_DEPENDS_ON} entries`);
+  }
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const dep of raw) {
+    const k = validateKey(String(dep ?? ""), `${path}.dependsOn`);
+    if (!seen.has(k)) {
+      seen.add(k);
+      out.push(k);
+    }
+  }
+  return out;
+}
+
+/**
+ * Apply a full task list to the plan on disk.
+ *
+ * Pure with respect to the filesystem: it takes the current list and returns
+ * the next one. `writeTaskList` is what persists it.
+ */
+export function applyTaskList(current: FeatureList, input: ApplyInput): ApplyResult {
+  if (input.baseRevision !== undefined && input.baseRevision !== current.baseRevision) {
+    throw new ValidationError(
+      `stale baseRevision: you sent ${input.baseRevision}, the plan is at ${current.baseRevision}. ` +
+        `Re-read the plan and resubmit.`,
+    );
+  }
+  if (!Array.isArray(input.tasks)) {
+    throw new ValidationError("tasks must be an array");
+  }
+  if (input.tasks.length > MAX_TASKS) {
+    throw new ValidationError(`tasks supports at most ${MAX_TASKS} items, got ${input.tasks.length}`);
+  }
+
+  const before = flattenTasks(current);
+  const storedByKey = new Map<string, FlatTask>();
+  for (const t of before) {
+    storedByKey.set(t.compositeKey, t);
+    storedByKey.set(t.id, t);
+    if (t.key) storedByKey.set(t.key, t);
+  }
+
+  // -- validate and merge each submitted task ------------------------------
+  type Staged = { featureId: string; task: Task; compositeKey: string };
+  const staged: Staged[] = [];
+  const seen = new Set<string>();
+
+  for (let i = 0; i < input.tasks.length; i++) {
+    const raw = input.tasks[i]!;
+    const path = `tasks[${i}]`;
+    const key = validateKey(String(raw?.key ?? ""), `${path}.key`);
+    if (seen.has(key)) throw new ValidationError(`${path}.key is duplicated: ${key}`);
+    seen.add(key);
+
+    const existing = storedByKey.get(key);
+    const { featureId: keyFeature, taskId } = splitKey(key);
+    const featureId = keyFeature ?? existing?.featureId ?? current.features[0]?.id ?? DEFAULT_FEATURE_ID;
+
+    const subject = raw.subject ?? raw.description ?? existing?.description;
+    if (subject === undefined) {
+      throw new ValidationError(`${path}.subject is required for new task ${key}`);
+    }
+    const description = String(subject).trim();
+    if (!description) throw new ValidationError(`${path}.subject must not be empty`);
+    if (description.length > MAX_DESCRIPTION_LEN) {
+      throw new ValidationError(`${path}.subject exceeds ${MAX_DESCRIPTION_LEN} characters`);
+    }
+
+    const statusRaw = raw.status ?? existing?.status;
+    if (statusRaw === undefined) {
+      throw new ValidationError(`${path}.status is required for new task ${key}`);
+    }
+    let status: TaskStatus;
+    try {
+      status = normalizeStatus(statusRaw);
+    } catch {
+      throw new ValidationError(`${path}.status is invalid: ${String(statusRaw)}`);
+    }
+
+    const dependsOn =
+      raw.dependsOn !== undefined ? validateDependsOn(raw.dependsOn, path) : [...(existing?.dependsOn ?? [])];
+
+    const subtasks =
+      raw.subtasks !== undefined
+        ? validateSubtasks(raw.subtasks, path)
+        : (existing?.subtasks ?? []).map((s) => ({ ...s }));
+
+    // Merge onto the stored task so unknown fields survive. `index`,
+    // `compositeKey`, `featureId` and `featureName` are view-only additions
+    // from flattenTasks and must not be persisted.
+    const base: Record<string, unknown> = existing ? { ...existing } : {};
+    delete base.index;
+    delete base.compositeKey;
+    delete base.featureId;
+    delete base.featureName;
+
+    const task: Task = {
+      ...(base as Partial<Task>),
+      id: taskId,
+      key,
+      description,
+      status,
+      dependsOn,
+      subtasks,
+    } as Task;
+
+    if (raw.difficulty !== undefined) task.difficulty = raw.difficulty as Task["difficulty"];
+    if (raw.modelHint !== undefined) task.modelHint = raw.modelHint;
+    if (raw.criteria !== undefined) task.criteria = raw.criteria;
+
+    staged.push({ featureId, task, compositeKey: key });
+  }
+
+  // -- dependency integrity -------------------------------------------------
+  const stagedKeys = new Set<string>();
+  for (const s of staged) {
+    stagedKeys.add(s.compositeKey);
+    stagedKeys.add(s.task.id);
+  }
+
+  const removedKeys = before.filter((t) => !stagedKeys.has(t.compositeKey) && !stagedKeys.has(t.id));
+  const removedComplete = new Set(
+    removedKeys.filter((t) => t.status === "complete").flatMap((t) => [t.compositeKey, t.id]),
+  );
+
+  for (const s of staged) {
+    // A dependency on a task that was deleted *because it was finished* is
+    // satisfied, not dangling — drop it rather than failing the write.
+    s.task.dependsOn = (s.task.dependsOn ?? []).filter((d) => !removedComplete.has(d));
+  }
+
+  for (let i = 0; i < staged.length; i++) {
+    const s = staged[i]!;
+    for (const dep of s.task.dependsOn ?? []) {
+      if (!stagedKeys.has(dep)) {
+        throw new ValidationError(`tasks[${i}].dependsOn references unknown task "${dep}"`);
+      }
+    }
+  }
+
+  detectCycle(staged.map((s) => ({ compositeKey: s.compositeKey, dependsOn: s.task.dependsOn })));
+
+  const statusByKey = new Map<string, TaskStatus>();
+  for (const s of staged) {
+    statusByKey.set(s.compositeKey, s.task.status);
+    statusByKey.set(s.task.id, s.task.status);
+  }
+  for (let i = 0; i < staged.length; i++) {
+    const s = staged[i]!;
+    if (s.task.status !== "in_progress" && s.task.status !== "complete") continue;
+    const unmet = (s.task.dependsOn ?? []).filter((d) => statusByKey.get(d) !== "complete");
+    if (unmet.length > 0) {
+      throw new ValidationError(
+        `tasks[${i}] (${s.compositeKey}) cannot be "${s.task.status}" while these are incomplete: ${unmet.join(", ")}`,
+      );
+    }
+  }
+
+  // -- rebuild the list, preserving feature metadata ------------------------
+  const next: FeatureList = structuredClone(current);
+  const featureById = new Map(next.features.map((f) => [f.id, f]));
+  for (const f of next.features) f.tasks = [];
+
+  for (const s of staged) {
+    let feature = featureById.get(s.featureId);
+    if (!feature) {
+      feature = { id: s.featureId, name: s.featureId, passes: false, tasks: [] };
+      next.features.push(feature);
+      featureById.set(s.featureId, feature);
+    }
+    feature.tasks.push(s.task);
+  }
+
+  // A feature passes when it has tasks and all of them are complete.
+  for (const f of next.features) {
+    f.passes = f.tasks.length > 0 && f.tasks.every((t) => t.status === "complete");
+  }
+
+  // -- diff -----------------------------------------------------------------
+  const added: string[] = [];
+  const updated: string[] = [];
+  for (const s of staged) {
+    const prev = storedByKey.get(s.compositeKey);
+    if (!prev) {
+      added.push(s.compositeKey);
+      continue;
+    }
+    const prevComparable = stripView(prev);
+    if (JSON.stringify(prevComparable) !== JSON.stringify(s.task)) updated.push(s.compositeKey);
+  }
+  const removed = removedKeys.map((t) => t.compositeKey);
+  const oldOrder = before.map((t) => t.compositeKey);
+  const newOrder = staged.map((s) => s.compositeKey);
+  const reordered =
+    oldOrder.length !== newOrder.length || oldOrder.some((k, i) => k !== newOrder[i]);
+
+  const changed = added.length > 0 || updated.length > 0 || removed.length > 0 || reordered;
+  next.baseRevision = changed ? current.baseRevision + 1 : current.baseRevision;
+
+  return {
+    revision: next.baseRevision,
+    list: next,
+    tasks: flattenTasks(next),
+    change: { added, updated, removed, reordered },
+    changed,
+  };
+}
+
+function stripView(t: FlatTask): Task {
+  const copy: Record<string, unknown> = { ...t };
+  delete copy.index;
+  delete copy.compositeKey;
+  delete copy.featureId;
+  delete copy.featureName;
+  return copy as Task;
+}
+
+/**
+ * Read the plan, apply the submission, and persist it — as one atomic section.
+ *
+ * The lock is not optional and not an optimisation. Read, check `baseRevision`,
+ * write is a classic check-then-act: two processes that both read revision N
+ * both pass the check and both write N+1, and one set of edits is gone. The
+ * revision guard catches a stale *read*; only mutual exclusion serialises the
+ * whole sequence.
+ *
+ * Fails closed. If the lock cannot be taken the write is refused with a
+ * `LockTimeoutError` the caller can retry, rather than racing and silently
+ * losing an edit.
+ */
+export function writeTaskList(targetDir: string, input: ApplyInput): ApplyResult {
+  return withLockSync(featureListPath(targetDir), () => {
+    const { list } = loadFeatureList(targetDir);
+    const result = applyTaskList(list, input);
+    if (result.changed) saveFeatureList(targetDir, result.list);
+    return result;
+  });
+}
+
+/** One-line summary of a write, for the tool result the model reads back. */
+export function summarizeApply(result: ApplyResult): string {
+  if (result.tasks.length === 0) return `Plan cleared (revision ${result.revision}).`;
+  const { added, updated, removed, reordered } = result.change;
+  const bits: string[] = [];
+  if (added.length) bits.push(`+${added.length}`);
+  if (updated.length) bits.push(`~${updated.length}`);
+  if (removed.length) bits.push(`-${removed.length}`);
+  if (reordered) bits.push("reordered");
+  const diff = bits.length ? ` (${bits.join(" ")})` : " (no change)";
+  const rows = result.tasks
+    .map((t) => `${t.index}. [${t.status}] ${t.compositeKey}: ${t.description}`)
+    .join("\n");
+  return `Plan revision ${result.revision}${diff}\n${rows}`;
+}

package/src/ui/config.ts

@@ -0,0 +1,286 @@
+/**
+ * infinity-harness — the settings TUI.
+ *
+ * Every option is reachable and editable from inside pi. Editing the JSON by
+ * hand still works and always will, but nobody should *have* to: a harness you
+ * can only configure by opening a file in another window is a harness people
+ * configure once, wrongly, and never touch again.
+ *
+ * The menu is generated from `core/settings.ts`, so adding an option there
+ * makes it appear here automatically.
+ *
+ * This module never imports pi. It talks to a `Prompter`, which the extension
+ * satisfies with `ctx.ui` and a test satisfies with a scripted fake — which is
+ * why the whole flow is testable without a terminal.
+ */
+
+import type { Setting, SettingsGroup } from "../core/settings.ts";
+import {
+  SETTINGS,
+  coerce,
+  formatValue,
+  readAll,
+  readSetting,
+  writeSetting,
+} from "../core/settings.ts";
+
+/** The subset of pi's UI this flow needs. */
+export type Prompter = {
+  select(title: string, options: string[]): Promise<string | undefined>;
+  input(title: string, placeholder?: string): Promise<string | undefined>;
+  notify(message: string, level?: "info" | "warning" | "error"): void;
+};
+
+/** A model pi has configured and can actually authenticate. */
+export type ModelChoice = {
+  /** How the harness stores it: `provider/id`. */
+  ref: string;
+  /** What the user sees. */
+  label: string;
+};
+
+export type ConfigMenuOptions = {
+  targetDir: string;
+  prompt: Prompter;
+  /** Models offered for any `model`-typed setting. */
+  models: () => ModelChoice[] | Promise<ModelChoice[]>;
+  /** Stop after one edit instead of returning to the menu. Used by tests. */
+  once?: boolean;
+};
+
+const BACK = "← back";
+const DONE = "✓ done";
+const INHERIT = "(use pi's current model)";
+const CUSTOM = "type a model id…";
+
+/**
+ * Run the settings menu until the user leaves.
+ *
+ * Returns the paths that were changed, so the caller can report what happened
+ * and refresh anything that reads config.
+ */
+export async function runConfigMenu(options: ConfigMenuOptions): Promise<string[]> {
+  const { targetDir, prompt } = options;
+  const changed: string[] = [];
+
+  for (;;) {
+    const io = readAll(targetDir);
+    const labels = SETTINGS.map((g) => `${g.label}  ·  ${summarize(g, io)}`);
+    const choice = await prompt.select("infinity-harness settings", [...labels, DONE]);
+    if (choice === undefined || choice === DONE) break;
+
+    const group = SETTINGS[labels.indexOf(choice)];
+    if (!group) break;
+
+    const edited = await runGroup(group, options, changed);
+    if (options.once && edited) break;
+  }
+
+  return changed;
+}
+
+/** One line per group so the top menu says something at a glance. */
+function summarize(group: SettingsGroup, io: ReturnType<typeof readAll>): string {
+  switch (group.id) {
+    case "models": {
+      const enabled = io.router.enabled;
+      if (!enabled) return "routing off";
+      const tiers = ["easy", "moderate", "difficult"]
+        .map((t) => (io.router.byDifficulty as Record<string, string> | undefined)?.[t])
+        .filter((v): v is string => Boolean(v && v.trim()));
+      return tiers.length ? `${tiers.length}/3 tiers set` : "routing on, no tiers set";
+    }
+    case "pipeline":
+      return (io.config.phases?.enabled ?? []).join(" → ") || "(none)";
+    case "commands": {
+      const set = Object.entries(io.config.commands ?? {}).filter(([, v]) => Boolean(v));
+      return set.length ? set.map(([k]) => k).join(", ") : "none set";
+    }
+    case "gates":
+      return io.config.gates?.enabled === false ? "DISABLED" : "on";
+    case "loop":
+      return `${io.config.loop?.maxIterations ?? "?"} turns · ${formatValue(
+        { type: { kind: "number", unit: "ms" } } as Setting,
+        io.config.loop?.maxWallClockMs,
+      )}`;
+    case "retries":
+      return `${io.config.maxRetries ?? "?"} per task`;
+    default:
+      return "";
+  }
+}
+
+async function runGroup(
+  group: SettingsGroup,
+  options: ConfigMenuOptions,
+  changed: string[],
+): Promise<boolean> {
+  const { targetDir, prompt } = options;
+  let edited = false;
+
+  for (;;) {
+    const io = readAll(targetDir);
+    const rows = group.settings.map((s) => `${s.label}: ${formatValue(s, readSetting(io, s))}`);
+    const choice = await prompt.select(`${group.label} — ${group.help}`, [...rows, BACK]);
+    if (choice === undefined || choice === BACK) return edited;
+
+    const setting = group.settings[rows.indexOf(choice)];
+    if (!setting) return edited;
+
+    const applied = await editSetting(setting, options);
+    if (applied) {
+      changed.push(setting.path);
+      edited = true;
+      if (options.once) return true;
+    }
+  }
+}
+
+/** Prompt for one setting and persist it. Returns whether anything changed. */
+async function editSetting(setting: Setting, options: ConfigMenuOptions): Promise<boolean> {
+  const { targetDir, prompt } = options;
+  const io = readAll(targetDir);
+  const current = readSetting(io, setting);
+
+  let raw: string | undefined;
+
+  switch (setting.type.kind) {
+    case "boolean": {
+      const picked = await prompt.select(`${setting.label} — ${setting.help}`, ["on", "off", BACK]);
+      if (picked === undefined || picked === BACK) return false;
+      raw = picked;
+      break;
+    }
+    case "choice": {
+      const picked = await prompt.select(`${setting.label} — ${setting.help}`, [
+        ...setting.type.choices,
+        BACK,
+      ]);
+      if (picked === undefined || picked === BACK) return false;
+      raw = picked;
+      break;
+    }
+    case "model": {
+      raw = await pickModel(setting, options, typeof current === "string" ? current : "");
+      if (raw === undefined) return false;
+      break;
+    }
+    case "multi": {
+      // Toggling one at a time beats asking someone to retype a whole list.
+      const selected = new Set(Array.isArray(current) ? (current as string[]) : []);
+      for (;;) {
+        const rows = setting.type.choices.map((c) => `${selected.has(c) ? "[x]" : "[ ]"} ${c}`);
+        const picked = await prompt.select(
+          `${setting.label} — ${setting.help}`,
+          [...rows, DONE, BACK],
+        );
+        if (picked === undefined || picked === BACK) return false;
+        if (picked === DONE) break;
+        const idx = rows.indexOf(picked);
+        const key = setting.type.choices[idx];
+        if (key === undefined) return false;
+        if (selected.has(key)) selected.delete(key);
+        else selected.add(key);
+      }
+      raw = [...selected].join(",");
+      break;
+    }
+    default: {
+      const shown = formatValue(setting, current);
+      const answer = await prompt.input(
+        `${setting.label} — ${setting.help}  [now: ${shown}]`,
+        setting.type.kind === "text" ? setting.type.placeholder : undefined,
+      );
+      if (answer === undefined) return false;
+      raw = answer;
+      break;
+    }
+  }
+
+  const result = coerce(setting, raw);
+  if (!result.ok) {
+    prompt.notify(`${setting.label}: ${result.error}`, "warning");
+    return false;
+  }
+
+  if (JSON.stringify(result.value) === JSON.stringify(current)) return false;
+
+  try {
+    writeSetting(targetDir, setting, result.value);
+  } catch (e) {
+    prompt.notify(
+      `could not save ${setting.label}: ${e instanceof Error ? e.message : String(e)}`,
+      "error",
+    );
+    return false;
+  }
+
+  prompt.notify(`${setting.label} → ${formatValue(setting, result.value)}`, "info");
+  return true;
+}
+
+/**
+ * Offer the models pi actually has, rather than asking someone to remember an
+ * id. Inheriting pi's current model is the first option because it is the
+ * right answer for most tiers most of the time.
+ */
+async function pickModel(
+  setting: Setting,
+  options: ConfigMenuOptions,
+  current: string,
+): Promise<string | undefined> {
+  const { prompt } = options;
+  let models: ModelChoice[] = [];
+  try {
+    models = await options.models();
+  } catch {
+    models = [];
+  }
+
+  if (models.length === 0) {
+    prompt.notify(
+      "pi reports no configured models — falling back to typing an id. Check `pi models` / your provider auth.",
+      "warning",
+    );
+    const typed = await prompt.input(`${setting.label} — ${setting.help}`, current || "provider/model-id");
+    return typed;
+  }
+
+  const rows = models.map((m) => (m.ref === current ? `${m.label}  ← current` : m.label));
+  const picked = await prompt.select(`${setting.label} — ${setting.help}`, [
+    INHERIT,
+    ...rows,
+    CUSTOM,
+    BACK,
+  ]);
+
+  if (picked === undefined || picked === BACK) return undefined;
+  if (picked === INHERIT) return "";
+  if (picked === CUSTOM) {
+    const typed = await prompt.input(`${setting.label} — model id`, current || "provider/model-id");
+    return typed;
+  }
+  const model = models[rows.indexOf(picked)];
+  return model?.ref;
+}
+
+/**
+ * A plain-text report of the whole configuration.
+ *
+ * Used by `/infinity:config show` and worth having on its own: it is the
+ * fastest way to answer "what is this run actually going to do?".
+ */
+export function renderSettings(targetDir: string): string {
+  const io = readAll(targetDir);
+  const lines: string[] = ["infinity-harness settings", ""];
+  for (const group of SETTINGS) {
+    lines.push(`${group.label}`);
+    for (const s of group.settings) {
+      const value = formatValue(s, readSetting(io, s));
+      lines.push(`  ${s.label.padEnd(28)} ${value}`);
+    }
+    lines.push("");
+  }
+  lines.push("Stored in harness/config.json and harness/model-router.json — both safe to edit by hand.");
+  return lines.join("\n");
+}