infinity-harness 2.3.1 → 2.4.0

package/src/ui/display.ts

@@ -0,0 +1,267 @@
+/**
+ * infinity-harness — display templates: what the surfaces actually draw.
+ *
+ * The plan has five levels, and shipping all five to everyone was the wrong
+ * answer for the same reason shipping two was: two people watching the same
+ * run want different things on screen. One works in sprints and never opens a
+ * subtask. The next has no sprints at all and lives in the subtask list. A run
+ * on a forty-task plan wants the shape; a run on one feature wants the detail.
+ *
+ * So the levels are a setting, three templates cover the common shapes, and
+ * anything else is a template the person builds and names. The terminal widget
+ * and the web dashboard read the same one, so what you configure once is what
+ * you see in both.
+ *
+ * Templates live with the *person* — `~/.pi/agent/infinity-harness/` — because
+ * how you like to read a plan does not change when you change project.
+ */
+
+import type { DisplayPolicy } from "../core/types.ts";
+import { userDisplayPath } from "../core/paths.ts";
+import { readJsonSafe, writeJsonAtomic, ensureDir } from "../core/fsx.ts";
+import { dirname } from "node:path";
+
+export type DisplayTemplate = {
+  id: string;
+  name: string;
+  description: string;
+  builtIn: boolean;
+  policy: DisplayPolicy;
+  savedAt?: string;
+};
+
+/** Everything on, at a size a terminal can hold. */
+export function defaultDisplay(): DisplayPolicy {
+  return {
+    preset: "focus",
+    levels: { goal: true, sprint: true, feature: true, task: true, subtask: "active" },
+    counts: true,
+    dependencies: true,
+    rail: true,
+    progress: true,
+    alerts: true,
+    criteria: true,
+    taskWindow: 9,
+  };
+}
+
+const focus: DisplayPolicy = defaultDisplay();
+
+const everything: DisplayPolicy = {
+  ...defaultDisplay(),
+  preset: "everything",
+  levels: { goal: true, sprint: true, feature: true, task: true, subtask: "all" },
+  taskWindow: 14,
+};
+
+/**
+ * The shape of the run, without the work.
+ *
+ * For a plan too big to read: goals and sprints and features with their
+ * counts, and no tasks at all. You come here to see which branch is stuck.
+ */
+const overview: DisplayPolicy = {
+  ...defaultDisplay(),
+  preset: "overview",
+  levels: { goal: true, sprint: true, feature: true, task: false, subtask: "none" },
+  dependencies: false,
+  criteria: false,
+  taskWindow: 12,
+};
+
+/**
+ * The work, and nothing else.
+ *
+ * For someone who already knows the plan and wants the next thing to do.
+ * No grouping rows, no meters, no rail.
+ */
+const worklist: DisplayPolicy = {
+  ...defaultDisplay(),
+  preset: "worklist",
+  levels: { goal: false, sprint: false, feature: false, task: true, subtask: "active" },
+  counts: false,
+  rail: false,
+  progress: true,
+  alerts: true,
+  criteria: false,
+  taskWindow: 12,
+};
+
+export const BUILTIN_DISPLAYS: DisplayTemplate[] = [
+  {
+    id: "focus",
+    name: "focus",
+    description: "The default: every level, with subtasks on the task being worked.",
+    builtIn: true,
+    policy: focus,
+  },
+  {
+    id: "everything",
+    name: "everything",
+    description: "All five levels, every subtask on every task, and a taller window.",
+    builtIn: true,
+    policy: everything,
+  },
+  {
+    id: "overview",
+    name: "overview",
+    description: "Goals, sprints and features with their counts. No tasks — the shape, not the work.",
+    builtIn: true,
+    policy: overview,
+  },
+  {
+    id: "worklist",
+    name: "worklist",
+    description: "Tasks only. No grouping rows, no rail — for when you already know the plan.",
+    builtIn: true,
+    policy: worklist,
+  },
+];
+
+export function builtInDisplay(id: string): DisplayTemplate | null {
+  return BUILTIN_DISPLAYS.find((d) => d.id === id) ?? null;
+}
+
+// ── the saved store ─────────────────────────────────────────────────────────
+
+type SavedStore = { version: string; displays: DisplayTemplate[] };
+
+export function slugify(name: string): string {
+  return String(name ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+}
+
+export function loadSavedDisplays(env?: NodeJS.ProcessEnv): DisplayTemplate[] {
+  const store = readJsonSafe<SavedStore | null>(userDisplayPath(env), null);
+  const list = Array.isArray(store?.displays) ? store.displays : [];
+  return list
+    .filter((d): d is DisplayTemplate => typeof d?.id === "string" && typeof d?.name === "string")
+    .map((d) => ({ ...d, builtIn: false, policy: normalizeDisplay(d.policy) }));
+}
+
+export function listDisplays(env?: NodeJS.ProcessEnv): DisplayTemplate[] {
+  return [...BUILTIN_DISPLAYS, ...loadSavedDisplays(env)];
+}
+
+export function findDisplay(id: string, env?: NodeJS.ProcessEnv): DisplayTemplate | null {
+  return listDisplays(env).find((d) => d.id === id) ?? null;
+}
+
+export type SaveResult = { ok: boolean; error: string | null; template?: DisplayTemplate };
+
+export function saveDisplay(
+  input: { name: string; description?: string; policy: DisplayPolicy },
+  env?: NodeJS.ProcessEnv,
+): SaveResult {
+  const name = String(input.name ?? "").trim();
+  if (!name) return { ok: false, error: "A template needs a name." };
+  const id = slugify(name);
+  if (!id) return { ok: false, error: `"${name}" has no letters or digits in it.` };
+  if (builtInDisplay(id)) {
+    return { ok: false, error: `"${name}" is a built-in template. Pick another name.` };
+  }
+
+  const policy = { ...normalizeDisplay(input.policy), preset: id };
+  const template: DisplayTemplate = {
+    id,
+    name,
+    description: (input.description ?? "").trim() || describeDisplay(policy),
+    builtIn: false,
+    policy,
+    savedAt: new Date().toISOString(),
+  };
+
+  const existing = loadSavedDisplays(env).filter((d) => d.id !== id);
+  const path = userDisplayPath(env);
+  try {
+    ensureDir(dirname(path));
+    writeJsonAtomic(path, { version: "1", displays: [...existing, template] } satisfies SavedStore);
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+  return { ok: true, error: null, template };
+}
+
+export function deleteDisplay(id: string, env?: NodeJS.ProcessEnv): SaveResult {
+  if (builtInDisplay(id)) return { ok: false, error: "Built-in templates cannot be deleted." };
+  const remaining = loadSavedDisplays(env).filter((d) => d.id !== id);
+  const path = userDisplayPath(env);
+  try {
+    ensureDir(dirname(path));
+    writeJsonAtomic(path, { version: "1", displays: remaining } satisfies SavedStore);
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+  return { ok: true, error: null };
+}
+
+// ── normalising ─────────────────────────────────────────────────────────────
+
+const SUBTASK_MODES = new Set(["none", "active", "all"]);
+
+/**
+ * Repair a policy read from disk.
+ *
+ * Every field is read on every render, in a lifecycle hook, so a hand-edited
+ * config with `levels: "yes"` in it must produce a widget rather than an
+ * exception that takes the session down.
+ */
+export function normalizeDisplay(raw: unknown): DisplayPolicy {
+  const base = defaultDisplay();
+  if (typeof raw !== "object" || raw === null) return base;
+  const r = raw as Partial<DisplayPolicy> & { levels?: Partial<DisplayPolicy["levels"]> };
+  const bool = (v: unknown, fallback: boolean): boolean => (typeof v === "boolean" ? v : fallback);
+
+  const window = typeof r.taskWindow === "number" && Number.isFinite(r.taskWindow) ? r.taskWindow : base.taskWindow;
+
+  return {
+    preset: typeof r.preset === "string" && r.preset.trim() ? r.preset.trim() : base.preset,
+    levels: {
+      goal: bool(r.levels?.goal, base.levels.goal),
+      sprint: bool(r.levels?.sprint, base.levels.sprint),
+      feature: bool(r.levels?.feature, base.levels.feature),
+      task: bool(r.levels?.task, base.levels.task),
+      subtask: SUBTASK_MODES.has(String(r.levels?.subtask))
+        ? (r.levels?.subtask as DisplayPolicy["levels"]["subtask"])
+        : base.levels.subtask,
+    },
+    counts: bool(r.counts, base.counts),
+    dependencies: bool(r.dependencies, base.dependencies),
+    rail: bool(r.rail, base.rail),
+    progress: bool(r.progress, base.progress),
+    alerts: bool(r.alerts, base.alerts),
+    criteria: bool(r.criteria, base.criteria),
+    // A window of zero is a widget with no plan in it, which nobody wants and
+    // which a typo can produce.
+    taskWindow: Math.max(3, Math.min(60, Math.round(window))),
+  };
+}
+
+/** Which template a policy currently matches, if any. */
+export function matchDisplay(policy: DisplayPolicy, env?: NodeJS.ProcessEnv): DisplayTemplate | null {
+  const same = (a: DisplayPolicy, b: DisplayPolicy): boolean =>
+    JSON.stringify({ ...normalizeDisplay(a), preset: "" }) ===
+    JSON.stringify({ ...normalizeDisplay(b), preset: "" });
+  return listDisplays(env).find((d) => same(d.policy, policy)) ?? null;
+}
+
+export function describeDisplay(policy: DisplayPolicy): string {
+  const p = normalizeDisplay(policy);
+  const on = (["goal", "sprint", "feature", "task"] as const).filter((k) => p.levels[k]);
+  const subtasks =
+    p.levels.subtask === "all" ? "all subtasks" : p.levels.subtask === "active" ? "active subtasks" : null;
+  const shown = [...on, ...(subtasks ? [subtasks] : [])];
+  return shown.length ? shown.join(" · ") : "nothing — every level is hidden";
+}
+
+/** One line for a menu row: `focus · goal · sprint · feature · task · active subtasks`. */
+export function summarizeDisplay(policy: DisplayPolicy, env?: NodeJS.ProcessEnv): string {
+  const p = normalizeDisplay(policy);
+  const named = matchDisplay(p, env);
+  const label = named ? named.name : `${p.preset} (edited)`;
+  return `${label} · ${describeDisplay(p)}`;
+}

package/src/ui/planTree.ts

@@ -55,6 +55,14 @@ export type PlanTreeOptions = {
    * goal and no sprints should not spend two rows saying so.
    */
   collapseTrivial?: boolean;
+  /**
+   * Which levels the reader has asked to see.
+   *
+   * A hidden level does not hide what is under it: turning off sprints on a
+   * plan organised into sprints must still show the features, one indent
+   * shallower, or the setting silently deletes half the plan from view.
+   */
+  levels?: Partial<Record<PlanLevel, boolean>>;
 };
 
 function taskCounts(tasks: Task[] | undefined): { done: number; total: number } {
@@ -185,35 +193,48 @@ export function buildPlanRows(
 ): PlanRow[] {
   const collapse = options.collapseTrivial !== false;
   const groups = groupPlan(list);
+  const wants = (level: PlanLevel): boolean => options.levels?.[level] !== false;
 
   // A single goal is the run's headline and the surface draws it separately.
-  const showGoals = collapse ? groups.filter((g) => g.goal !== null).length > 1 : groups.some((g) => g.goal);
-  const showSprints = groups.some((g) => g.sprints.some((sg) => sg.sprint !== null));
+  const showGoals =
+    wants("goal") &&
+    (collapse ? groups.filter((g) => g.goal !== null).length > 1 : groups.some((g) => g.goal));
+  const showSprints = wants("sprint") && groups.some((g) => g.sprints.some((sg) => sg.sprint !== null));
 
   const rows: PlanRow[] = [];
   let taskIndex = 0;
 
   const emitFeature = (feature: Feature, depth: number): void => {
     const counts = taskCounts(feature.tasks);
-    rows.push({
-      level: "feature",
-      depth,
-      id: feature.id,
-      label: feature.id,
-      title: feature.name ?? feature.id,
-      status: null,
-      done: counts.done,
-      total: counts.total,
-      criteria: Array.isArray(feature.criteria) ? feature.criteria : undefined,
-    });
+    let taskDepth = depth;
+    if (wants("feature")) {
+      rows.push({
+        level: "feature",
+        depth,
+        id: feature.id,
+        label: feature.id,
+        title: feature.name ?? feature.id,
+        status: null,
+        done: counts.done,
+        total: counts.total,
+        criteria: Array.isArray(feature.criteria) ? feature.criteria : undefined,
+      });
+    } else {
+      // Hiding the feature row must not hide its tasks — nor indent them as
+      // though the row were still there.
+      taskDepth = Math.max(0, depth - 1);
+    }
 
     for (const task of feature.tasks ?? []) {
+      // Numbered even when hidden: `← #3` has to keep meaning the same task
+      // whatever the reader has chosen to look at.
       taskIndex += 1;
+      if (!wants("task")) continue;
       const id = task.key ?? `${feature.id}/${task.id}`;
       const active = activeTaskId !== null && (id === activeTaskId || task.id === activeTaskId);
       rows.push({
         level: "task",
-        depth: depth + 1,
+        depth: taskDepth + 1,
         id,
         label: String(taskIndex),
         title: task.description ?? id,
@@ -233,8 +254,8 @@ export function buildPlanRows(
       // one, so a task that is plainly in progress counts too.
       const subs = Array.isArray(task.subtasks) ? task.subtasks : [];
       const working = task.status === "in_progress" || task.status === "rework";
-      const show = options.expandSubtasks || active || working;
-      if (show && subs.length) rows.push(...subtaskRows(task, id, depth + 2, subs));
+      const show = wants("subtask") && (options.expandSubtasks || active || working);
+      if (show && subs.length) rows.push(...subtaskRows(task, id, taskDepth + 2, subs));
     }
   };
 
@@ -255,6 +276,7 @@ export function buildPlanRows(
     }
     for (const sg of group.sprints) {
       let featureDepth = depth;
+      // Every feature row hidden means the tasks sit where the features were.
       if (showSprints && sg.sprint) {
         rows.push({
           level: "sprint",

package/src/ui/widget.ts

@@ -16,6 +16,8 @@ import type { FeatureList, Phase, TaskStatus } from "../core/types.ts";
 import { computeProgress, flattenTasks, nextActionableTask } from "../core/featureList.ts";
 import { getPhaseOrder } from "../core/phases.ts";
 import { buildPlanRows, focusRowIndex, type PlanRow } from "./planTree.ts";
+import { defaultDisplay, normalizeDisplay } from "./display.ts";
+import type { DisplayPolicy } from "../core/types.ts";
 import {
   createStyler,
   detectGlyphs,
@@ -73,6 +75,13 @@ export type WidgetState = {
   view?: WidgetView | null;
   /** Sessions this run has spent. Only meaningful once handoff is on. */
   sessions?: number | null;
+  /**
+   * What this reader has asked to see.
+   *
+   * The same policy drives the dashboard, so a level turned off here is off
+   * there too — configuring how you read a plan once, rather than twice.
+   */
+  display?: DisplayPolicy | null;
   /**
    * What the human asked for, before a plan exists to hold a goal.
    *
@@ -268,26 +277,30 @@ function renderRow(
   indexByKey: Map<string, number>,
   g: GlyphSet,
   s: Styler,
+  display: DisplayPolicy,
 ): string[] {
   const indent = "  ".repeat(row.depth);
+  const tagFor = (r: PlanRow): string => (display.counts ? countTag(r, s) : "");
 
   if (row.level === "goal" || row.level === "sprint") {
     const icon = s.fg(LEVEL_ROLE[row.level], row.level === "goal" ? g.goal : g.sprint);
-    const tag = countTag(row, s);
+    const tag = tagFor(row);
     const prefix = indent + icon + " ";
     const head =
       s.bold(s.fg(LEVEL_ROLE[row.level], row.title)) +
       (row.label && row.label !== row.title ? s.fg("rule", "  " + row.label) : "");
-    const body = truncate(prefix + head, Math.max(8, inner - width(tag) - 1));
+    const body = truncate(prefix + head, tag ? Math.max(8, inner - width(tag) - 1) : inner);
+    if (!tag) return [body];
     const gap = Math.max(1, inner - width(body) - width(tag));
     return [body + " ".repeat(gap) + tag];
   }
 
   if (row.level === "feature") {
-    const tag = countTag(row, s);
+    const tag = tagFor(row);
     const prefix = indent + s.fg("muted", g.branch + " ");
     const head = s.fg("muted", row.label) + s.fg("rule", " · ") + s.fg("text", row.title);
-    const body = truncate(prefix + head, Math.max(8, inner - width(tag) - 1));
+    const body = truncate(prefix + head, tag ? Math.max(8, inner - width(tag) - 1) : inner);
+    if (!tag) return [body];
     const gap = Math.max(1, inner - width(body) - width(tag));
     return [body + " ".repeat(gap) + tag];
   }
@@ -307,7 +320,7 @@ function renderRow(
   const role = statusRole(row.status ?? "pending");
   const icon = s.fg(role, statusGlyph(row.status ?? "pending", g));
   const num = s.fg("rule", row.label);
-  const dep = depLabel(row.dependsOn, indexByKey, g, s);
+  const dep = display.dependencies ? depLabel(row.dependsOn, indexByKey, g, s) : "";
   const prefix = indent + icon + " " + num + " ";
   const prefixW = width(prefix);
   const depW = dep ? width(dep) + 1 : 0;
@@ -369,7 +382,9 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   const pad = boxed ? 2 : 0;
   const inner = Math.max(24, total - pad * 2);
   const view = state.view ?? defaultView();
-  const limit = options.taskWindow ?? (view.expanded ? EXPANDED_WINDOW : TASK_WINDOW);
+  const display = normalizeDisplay(state.display ?? defaultDisplay());
+  const limit =
+    options.taskWindow ?? (view.expanded ? Math.max(EXPANDED_WINDOW, display.taskWindow * 2) : display.taskWindow);
 
   const out: string[] = [];
   const push = (line = ""): void => {
@@ -398,7 +413,13 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   // the tree — `buildPlanRows` collapses it there for exactly this reason.
   // Several goals are structure, and structure belongs in the tree.
   const goals = state.list.goals ?? [];
-  const headline = goals.length === 1 ? (goals[0]?.title ?? null) : goals.length === 0 ? (state.intake ?? null) : null;
+  const headline = !display.levels.goal
+    ? null
+    : goals.length === 1
+      ? (goals[0]?.title ?? null)
+      : goals.length === 0
+        ? (state.intake ?? null)
+        : null;
   if (headline) {
     const wrapped = wrap(headline, inner - 2);
     wrapped.forEach((line, i) => {
@@ -409,8 +430,10 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   }
 
   // -- phase rail -----------------------------------------------------------
-  push();
-  push(phaseRail(state.phase, state.enabledPhases, inner, g, s));
+  if (display.rail) {
+    push();
+    push(phaseRail(state.phase, state.enabledPhases, inner, g, s));
+  }
 
   // -- progress -------------------------------------------------------------
   const full =
@@ -427,12 +450,14 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   if (inner - width(full) < METER_MIN) stats = compact;
   if (inner - width(stats) < METER_MIN) stats = "";
 
-  const statsW = width(stats);
-  const barCells = Math.max(8, Math.min(24, inner - statsW - 8));
-  const bar = progressBar(progress.percent, barCells, g, s);
-  push();
-  const gap2 = inner - width(bar) - statsW;
-  push(truncate(bar + (gap2 > 0 ? " ".repeat(gap2) : " ") + stats, inner));
+  if (display.progress) {
+    const statsW = width(stats);
+    const barCells = Math.max(8, Math.min(24, inner - statsW - 8));
+    const bar = progressBar(progress.percent, barCells, g, s);
+    push();
+    const gap2 = inner - width(bar) - statsW;
+    push(truncate(bar + (gap2 > 0 ? " ".repeat(gap2) : " ") + stats, inner));
+  }
 
   // -- alerts ---------------------------------------------------------------
   const alerts: string[] = [];
@@ -462,7 +487,7 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   if (state.gate && !state.gate.overall) {
     alerts.push(s.fg("blocked", "gate: " + state.gate.failures.slice(0, 3).join(", ")));
   }
-  if (alerts.length) push(truncate(alerts.join(s.fg("rule", " · ")), inner));
+  if (display.alerts && alerts.length) push(truncate(alerts.join(s.fg("rule", " · ")), inner));
 
   // -- the plan -------------------------------------------------------------
   //
@@ -484,7 +509,14 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
 
   const active = nextActionableTask(state.list);
   const rows = buildPlanRows(state.list, active?.compositeKey ?? null, {
-    expandSubtasks: view.expanded,
+    expandSubtasks: view.expanded || display.levels.subtask === "all",
+    levels: {
+      goal: display.levels.goal,
+      sprint: display.levels.sprint,
+      feature: display.levels.feature,
+      task: display.levels.task,
+      subtask: display.levels.subtask !== "none",
+    },
   });
 
   const bounds = rowWindow(rows, limit, view.scroll);
@@ -497,7 +529,7 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   }
 
   for (const row of rows.slice(bounds.start, bounds.end)) {
-    for (const line of renderRow(row, inner, indexByKey, g, s)) push(line);
+    for (const line of renderRow(row, inner, indexByKey, g, s, display)) push(line);
   }
 
   if (hiddenAfter > 0) {