@dieulc/workflow 0.6.1 → 0.8.0

package/picker.ts

@@ -0,0 +1,246 @@
+/**
+ * Filterable picker primitives shared by the `/profile` and `/role` overlays.
+ *
+ * pi-tui's `SelectList` deliberately has no text composer: `handleInput()` only
+ * understands Up/Down/Enter/Escape and silently drops printable keys, while
+ * `setFilter()` is a prefix match on `item.value`. pi's own `/model` selector
+ * solves this with an `Input` + `fuzzyFilter`; this module exposes the same
+ * shape as a reusable component because pi's selector lives in pi's internal
+ * `dist/` and is not a public export.
+ *
+ * Contract for `FilterableList.handleInput(data)`:
+ *   - returns `true` when the key was consumed by the composer or list;
+ *   - returns `false` for Enter (`tui.select.confirm`) and for the cancel key
+ *     when the filter is already empty, so the caller can apply its own
+ *     confirm / back / cancel semantics (Enter on a no-match list must stay
+ *     inert instead of closing the overlay).
+ */
+
+import {
+  Input,
+  Key,
+  SelectList,
+  fuzzyFilter,
+  getKeybindings,
+  matchesKey,
+  type SelectItem,
+  type SelectListLayoutOptions,
+  type SelectListTheme,
+} from "@earendil-works/pi-tui";
+
+/** A selectable row plus hidden text that the filter may match but never renders. */
+export interface FilterableItem extends SelectItem {
+  /**
+   * Extra search-only text (e.g. a model's display name). `SelectList` ignores
+   * unknown properties, so this never affects the rendered columns.
+   */
+  searchText?: string;
+}
+
+/** The text a row is matched against: label, value, description and hidden text. */
+export function pickerItemText(item: FilterableItem): string {
+  const parts: string[] = [];
+  const seen = new Set<string>();
+  for (const part of [
+    item.label,
+    item.value,
+    item.description,
+    item.searchText,
+  ]) {
+    if (!part) continue;
+    const text = part.trim();
+    // Model rows use the ref as both label and value; dedupe so the fuzzy
+    // scorer does not weight the same string twice (and can still award the
+    // exact-match bonus).
+    if (!text || seen.has(text)) continue;
+    seen.add(text);
+    parts.push(text);
+  }
+  return parts.join(" ");
+}
+
+/**
+ * Fuzzy-filter `items` (best match first). A blank query returns every item.
+ * Matching uses `fuzzyFilter`, so whitespace- and slash-separated tokens all
+ * have to match; it is case-insensitive.
+ */
+export function filterPickerItems<T extends FilterableItem>(
+  items: readonly T[],
+  query: string,
+  getText: (item: T) => string = pickerItemText,
+): T[] {
+  const all = [...items];
+  if (!query.trim()) return all;
+  return fuzzyFilter(all, query, getText);
+}
+
+export interface FilterableListOptions {
+  items: readonly FilterableItem[];
+  maxVisible: number;
+  theme: SelectListTheme;
+  layout?: SelectListLayoutOptions;
+  /** Seed the composer (e.g. a filter remembered across a re-opened picker). */
+  initialQuery?: string;
+  /** Initial cursor when the query is empty. */
+  initialIndex?: number;
+  /** Filter-text builder; defaults to `pickerItemText`. */
+  searchText?: (item: FilterableItem) => string;
+  /** Message shown when nothing matches (without the two-space indent). */
+  noMatchText?: string;
+}
+
+/**
+ * A `SelectList` paired with an `Input` composer and fuzzy filtering.
+ *
+ * `SelectList` has no item setter, so the inner list is rebuilt whenever the
+ * filtered set changes. The wrapper itself is stable, which is what callers
+ * keep per tab so filter text and cursor survive tab switches.
+ */
+export class FilterableList {
+  private items: FilterableItem[];
+  private filtered: FilterableItem[];
+  private query: string;
+  private readonly maxVisible: number;
+  private readonly theme: SelectListTheme;
+  private readonly layout: SelectListLayoutOptions | undefined;
+  private readonly searchText: (item: FilterableItem) => string;
+  private readonly noMatchText: string;
+  private readonly input: Input;
+  private inner: SelectList;
+
+  constructor(opts: FilterableListOptions) {
+    this.items = [...opts.items];
+    this.maxVisible = opts.maxVisible;
+    this.theme = opts.theme;
+    this.layout = opts.layout;
+    this.searchText = opts.searchText ?? pickerItemText;
+    this.noMatchText = opts.noMatchText ?? "No matching entries";
+    this.input = new Input();
+    // Input.setValue() clamps the cursor instead of moving it to the end, so a
+    // remembered query is seeded by simulating typing. Otherwise the next key
+    // would be inserted at position 0.
+    if (opts.initialQuery) this.input.handleInput(opts.initialQuery);
+    this.query = this.input.getValue();
+    this.filtered = filterPickerItems(this.items, this.query, this.searchText);
+    this.inner = new SelectList(
+      this.filtered,
+      this.maxVisible,
+      this.theme,
+      this.layout,
+    );
+    if (!this.query && opts.initialIndex && opts.initialIndex > 0) {
+      this.inner.setSelectedIndex(opts.initialIndex);
+    }
+  }
+
+  /** Current filter text ("" when unfiltered). */
+  getQuery(): string {
+    return this.query;
+  }
+
+  /** All rows, unfiltered. */
+  getItems(): readonly FilterableItem[] {
+    return this.items;
+  }
+
+  /** Rows matching the current query (the list the user is navigating). */
+  getFilteredItems(): readonly FilterableItem[] {
+    return this.filtered;
+  }
+
+  /** The highlighted row, or null when nothing matches. */
+  getSelectedItem(): SelectItem | null {
+    return this.inner.getSelectedItem();
+  }
+
+  /** Move the cursor (only meaningful while the query is empty). */
+  setSelectedIndex(index: number): void {
+    this.inner.setSelectedIndex(index);
+  }
+
+  /** Reset the filter and restore the full list. */
+  clearFilter(): void {
+    if (!this.query) return;
+    this.applyQuery("");
+  }
+
+  /**
+   * Replace the rows (e.g. Ctrl+O scope toggle). The query and the selected
+   * value are preserved when they still exist in the new set.
+   */
+  setItems(items: readonly FilterableItem[]): void {
+    const previous = this.inner.getSelectedItem()?.value;
+    this.items = [...items];
+    this.refilter(previous);
+  }
+
+  /** One composer line, sized to `width`. */
+  renderQuery(width: number): string[] {
+    return this.input.render(Math.max(1, width));
+  }
+
+  /** The filtered list, or a themed no-match line, sized to `width`. */
+  renderList(width: number): string[] {
+    if (this.filtered.length === 0) {
+      return [this.theme.noMatch(`  ${this.noMatchText}`)];
+    }
+    return this.inner.render(Math.max(1, width));
+  }
+
+  /**
+   * Navigation + filter editing. Returns false for keys the caller owns:
+   * Enter, and Escape/Ctrl+C when the filter is empty.
+   */
+  handleInput(data: string): boolean {
+    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+      if (this.query) {
+        this.applyQuery("");
+        return true;
+      }
+      return false;
+    }
+    const kb = getKeybindings();
+    if (
+      kb.matches(data, "tui.select.up") ||
+      kb.matches(data, "tui.select.down")
+    ) {
+      if (this.filtered.length > 0) this.inner.handleInput(data);
+      return true;
+    }
+    if (kb.matches(data, "tui.select.confirm")) return false;
+    this.input.handleInput(data);
+    const next = this.input.getValue();
+    if (next !== this.query) this.applyQuery(next);
+    return true;
+  }
+
+  /** Apply a new query, resetting to the top match or restoring the previous row. */
+  private applyQuery(next: string): void {
+    const previous = this.inner.getSelectedItem()?.value;
+    this.query = next;
+    if (this.input.getValue() !== next) this.input.setValue(next);
+    this.refilter(previous);
+  }
+
+  private refilter(previous: string | undefined): void {
+    this.filtered = filterPickerItems(
+      this.items,
+      this.query,
+      this.searchText,
+    );
+    this.inner = new SelectList(
+      this.filtered,
+      this.maxVisible,
+      this.theme,
+      this.layout,
+    );
+    if (this.query) {
+      this.inner.setSelectedIndex(0);
+      return;
+    }
+    const index = previous
+      ? this.filtered.findIndex((item) => item.value === previous)
+      : -1;
+    this.inner.setSelectedIndex(Math.max(0, index));
+  }
+}

package/profiles.ts

@@ -55,6 +55,8 @@ export interface Profile {
   description: string;
   /** Partial by design: hand-edited files may override a subset of roles. */
   roles: Partial<Record<ProfileRoleName, RoleModel>>;
+  /** Optional model used in Default mode (chat). Not a role — roles.json is untouched. */
+  defaultModel?: RoleModel;
 }
 
 export interface ProfileConfig {
@@ -240,11 +242,17 @@ export function sanitizeProfile(p: any): Profile | undefined {
     const m = sanitizeProfileModel((rawRoles as any)[roleName]);
     if (m) roles[roleName] = m;
   }
-  if (Object.keys(roles).length === 0) return undefined;
+  // Default-mode model: prefer the dedicated field, fall back to a
+  // `roles.default` alias for hand-edited files.
+  const defaultModel =
+    sanitizeProfileModel(p.defaultModel) ??
+    sanitizeProfileModel((rawRoles as any).default);
+  if (Object.keys(roles).length === 0 && !defaultModel) return undefined;
   return {
     name: nameCheck.value,
     description: typeof p.description === "string" ? p.description.trim() : "",
     roles,
+    ...(defaultModel ? { defaultModel } : {}),
   };
 }
 
@@ -411,12 +419,52 @@ export function applyProfileOverlay(
 
 // ── Display ──────────────────────────────────────────────────────────
 
+/** One selectable model row for pi-tui's `SelectList`. */
+export interface ModelPickerItem {
+  value: string;
+  label: string;
+  /**
+   * Hidden search text (the model's display name). Never rendered: `SelectList`
+   * only reads value/label/description, so this cannot reserve a column or
+   * truncate the ref.
+   */
+  searchText?: string;
+}
+
+/**
+ * The rows of a model picker: the **full** `provider/id` in the label, never a
+ * `description`.
+ *
+ * pi-tui reserves a fixed 32-cell primary column whenever a row has a
+ * description (and truncates the label to 30), which is what used to cut long
+ * refs such as `synthetic/hf:deepseek-ai/DeepSeek-V4.1-Flash-1017` even on a wide
+ * pane. Selection and scope state belong in the picker header, not in a column.
+ * The optional display name travels as `searchText`, so typing what `/model`
+ * shows (e.g. "DeepSeek V4.1 Flash") still matches without touching the row's
+ * visible shape.
+ */
+export function modelPickerItems(
+  entries: readonly { provider: string; id: string; name?: string }[],
+): ModelPickerItem[] {
+  return entries.map((entry) => {
+    const ref = `${entry.provider}/${entry.id}`;
+    const name = entry.name?.trim();
+    return name
+      ? { value: ref, label: ref, searchText: name }
+      : { value: ref, label: ref };
+  });
+}
+
 /** One-line summary: `⚡ cheap — 🧠 a/b (high) · 🔍 …` (for picker rows). */
 export function formatProfileOneLine(p: Profile): string {
   const parts = PROFILE_ROLES.map((r) => {
     const m = p.roles[r];
     return m ? `${roleIcon(r)} ${formatModelRef(m)} (${m.thinking})` : `${roleIcon(r)} —`;
   });
+  if (p.defaultModel) {
+    const m = p.defaultModel;
+    parts.push(`◦ ${formatModelRef(m)} (${m.thinking})`);
+  }
   const desc = p.description ? ` — ${p.description}` : "";
   return `⚡ ${p.name}${desc}: ${parts.join(" · ")}`;
 }
@@ -433,9 +481,33 @@ export function describeProfile(p: Profile): string {
       }`,
     );
   }
+  const dm = p.defaultModel;
+  lines.push(
+    `  ◦ default: ${
+      dm ? `${formatModelRef(dm)} (${dm.thinking})` : "(not set — keeps current Default-mode model)"
+    }`,
+  );
   return lines.join("\n");
 }
 
+// ── Picker flow ──────────────────────────────────────────────────────
+
+/** Result of a `/profile` sub-flow (editor, default picker, action). */
+export type ProfileFlowOutcome = "completed" | "cancelled" | "failed";
+
+/**
+ * Whether a finished `/profile` sub-flow closes the picker overlay.
+ *
+ * Only a completed action closes it. Cancelled or failed sub-flows stay on the
+ * profile list so the user can retry or choose another action, and the action
+ * menu's "back" entry is navigation, never a close.
+ */
+export function profileActionClosesPicker(
+  outcome: ProfileFlowOutcome | "back",
+): boolean {
+  return outcome === "completed";
+}
+
 export function formatProfilesForDisplay(
   config: ProfileConfig,
   activeName?: string | null,
@@ -473,6 +545,12 @@ export function formatProfilesForDisplay(
         }`,
       );
     }
+    const dm = p.defaultModel;
+    lines.push(
+      `     ◦ default: ${
+        dm ? `${formatModelRef(dm)} (${dm.thinking})` : "(current Default-mode model)"
+      }`,
+    );
   }
   lines.push("");
   lines.push(
@@ -509,6 +587,25 @@ export function defaultProfileSettingPaths(
   };
 }
 
+/**
+ * Which scope a `workflow.defaultProfile` write should target: the project file
+ * when it already defines the key (so an existing project value stays
+ * effective), otherwise global.
+ *
+ * Mirrors `modelDefaultWriteScope` in model-default.ts. Without this, an
+ * activation would write global while a project value kept shadowing it, and
+ * the write would silently do nothing.
+ */
+export function defaultProfileWriteScope(
+  cwd: string,
+  agentDir: string,
+): "global" | "project" {
+  const paths = defaultProfileSettingPaths(cwd, agentDir);
+  return extractDefaultProfile(readSettingsSafe(paths.project)) !== undefined
+    ? "project"
+    : "global";
+}
+
 /**
  * Extract `workflow.defaultProfile` (a profile name string) from a raw
  * settings object. Anything else (absent, non-string, blank) → undefined.