pi-weave 0.3.8 → 0.3.9

package/src/pi/viewer/tui/surface/health.ts

@@ -1,102 +0,0 @@
-/**
- * surface/health.ts — the Health surface as a Component (weave-view-tui-v2 §6).
- *
- * Renders `healthModel` (staleness + link health). Enter on a health row with
- * a target opens that node in detail (emitted as a SurfaceEvent).
- */
-
-import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
-import { healthModel, sanitizeTerminalText } from "../model";
-import { windowLines, type Surface, type SurfaceEvent, type SurfaceInit } from "./base";
-
-export interface HealthSurfaceState {
-  selectedId: string | null;
-  scrollOffset: number;
-}
-
-export class HealthSurface implements Surface {
-  readonly kind = "health" as const;
-  private readonly ctx;
-  private readonly onEvent: ((e: SurfaceEvent) => void) | undefined;
-  state: HealthSurfaceState;
-  paneRows = 24;
-
-  constructor(init: SurfaceInit) {
-    this.ctx = init.context;
-    this.onEvent = init.onEvent;
-    this.state = { selectedId: null, scrollOffset: 0 };
-  }
-
-  title(): string {
-    return "Health";
-  }
-
-  setFocused(_focused: boolean): void {}
-
-  invalidate(): void {}
-
-  handleInput(data: string): void {
-    if (matchesKey(data, "up")) return this.move(-1);
-    if (matchesKey(data, "down")) return this.move(1);
-    if (matchesKey(data, "pageUp")) return this.movePage(-1);
-    if (matchesKey(data, "pageDown")) return this.movePage(1);
-    if (matchesKey(data, "home")) {
-      this.state = { ...this.state, selectedId: this.rows()[0]?.id ?? null, scrollOffset: 0 };
-      return;
-    }
-    if (matchesKey(data, "end")) {
-      const r = this.rows();
-      const last = r[r.length - 1];
-      this.state = { ...this.state, selectedId: last?.id ?? null, scrollOffset: Math.max(0, r.length - this.paneRows) };
-      return;
-    }
-    if (matchesKey(data, "enter")) {
-      const rows = this.rows();
-      const idx = rows.findIndex((r) => r.id === this.state.selectedId);
-      const row = idx >= 0 ? rows[idx] : undefined;
-      if (row && row.target) this.onEvent?.({ type: "openDetail", id: row.target });
-      return;
-    }
-  }
-
-  private move(delta: 1 | -1): void {
-    const rows = this.rows();
-    if (rows.length === 0) return;
-    const idx = rows.findIndex((r) => r.id === this.state.selectedId);
-    const nextIdx = Math.max(0, Math.min(rows.length - 1, (idx < 0 ? -1 : idx) + delta));
-    const row = rows[nextIdx]!;
-    this.state = { ...this.state, selectedId: row.id };
-  }
-
-  private movePage(dir: 1 | -1): void {
-    const rows = this.rows();
-    const idx = rows.findIndex((r) => r.id === this.state.selectedId);
-    const target = idx < 0 ? 0 : Math.max(0, Math.min(rows.length - 1, idx + dir * this.paneRows));
-    const row = rows[target];
-    if (row) this.state = { ...this.state, selectedId: row.id };
-  }
-
-  private rows(): { id: string; target?: string }[] {
-    const h = healthModel(this.ctx.model);
-    return h.sections.flatMap((s) =>
-      s.rows.filter((r) => r.target).map((r): { id: string; target?: string } => ({ id: r.id, target: r.target! })),
-    );
-  }
-
-  render(width: number): string[] {
-    const t = this.ctx.theme;
-    const h = healthModel(this.ctx.model);
-    const lines: { text: string; id?: string }[] = [];
-    for (const s of h.sections) {
-      lines.push({ text: t.bold(s.heading) });
-      for (const r of s.rows) {
-        lines.push({ text: sanitizeTerminalText(r.text), id: r.id });
-      }
-    }
-    const selId = this.state.selectedId;
-    const selLine = selId ? lines.findIndex((l) => l.id === selId) : -1;
-    const marker = (text: string) => `› ${this.ctx.theme.bg("selectedBg", text)}`;
-    const windowed = windowLines(lines.map((l) => l.text), selLine, this.state.scrollOffset, Math.max(5, this.paneRows), marker);
-    return windowed.map((l) => truncateToWidth(l, width));
-  }
-}

package/src/pi/viewer/tui/theme.ts

@@ -1,90 +0,0 @@
-/**
- * Provenance & kind → glyph + theme color-slot maps for the weave-view TUI
- * (weave-view-tui-design §7).
- *
- * Pure data: imports only core types. Theme slots are names only
- * (`theme.fg(slot, …)` applies the actual color), so pi themes restyle
- * everything — never hardcoded hex. Style-first per v2 P1: provenance is
- * glyph + dimness, color is the weak secondary channel.
- */
-
-import type { NodeKind } from "../../../core/graph/model";
-import type { NoteSource } from "../../../core/types";
-
-/** Theme foreground color-slot names understood by pi's `Theme`. */
-export type ThemeSlot =
-  | "accent"
-  | "success"
-  | "warning"
-  | "dim"
-  | "muted"
-  | "text";
-
-/** Provenance rendering: glyph prefix, whole-row dimness, and theme slot. */
-export interface ProvenanceStyle {
-  glyph: string;
-  /** When true, the whole row is rendered dim (generated knowledge). */
-  dim: boolean;
-  slot: ThemeSlot;
-  /** Word printed in the provenance cycle / header banner, e.g. "human". */
-  word: string;
-}
-
-/** The provenance cycle order for the `p` key: all → human → agent → generated → all. */
-export const PROVENANCE_CYCLE: readonly (NoteSource | null)[] = [null, "human", "agent", "generated"];
-
-export function provenanceStyle(prov: NoteSource | null): ProvenanceStyle {
-  switch (prov) {
-    case "human":
-      return { glyph: "●", dim: false, slot: "success", word: "human" };
-    case "agent":
-      return { glyph: "◐", dim: false, slot: "accent", word: "agent" };
-    case "generated":
-      return { glyph: "○", dim: true, slot: "dim", word: "generated" };
-    default:
-      // structural node — no provenance glyph; kind glyph leads.
-      return { glyph: "", dim: false, slot: "muted", word: "" };
-  }
-}
-
-export interface KindStyle {
-  glyph: string;
-  slot: ThemeSlot;
-}
-
-/** Kind → glyph + slot. Notes defer to their provenance glyph (trust-first). */
-export function kindStyle(kind: NodeKind): KindStyle {
-  switch (kind) {
-    case "vault":
-      return { glyph: "◆", slot: "accent" };
-    case "note":
-      // provenance glyph leads; kind slot unused for the marker.
-      return { glyph: "", slot: "text" };
-    case "repository":
-      return { glyph: "■", slot: "accent" };
-    case "module":
-      return { glyph: "▪", slot: "success" };
-    case "package":
-      return { glyph: "▲", slot: "success" };
-    case "entryPoint":
-      return { glyph: "▹", slot: "warning" };
-    case "gitState":
-      return { glyph: "⎇", slot: "warning" };
-    case "external":
-      return { glyph: "↗", slot: "warning" };
-    case "file":
-      return { glyph: "·", slot: "dim" };
-  }
-}
-
-/** Chevron shown for an expandable tree row. */
-export function chevron(expanded: boolean, hasKids: boolean): string {
-  if (!hasKids) return " ";
-  return expanded ? "▾" : "▸";
-}
-
-/** Selection gutter marker. */
-export const SELECTION_MARKER = "›";
-
-/** Maximum length of the inline search/filter string (design §9.4). */
-export const MAX_FILTER_LEN = 200;

package/src/pi/viewer/tui/workspace.ts

@@ -1,53 +0,0 @@
-import type { GraphModel } from "../../../core/graph/model";
-import { graphRoots } from "./model";
-
-export type SurfaceKind = "explore" | "detail" | "focus" | "health";
-
-export interface PaneNode {
-  id: string;
-  surface: SurfaceKind;
-  nodeId: string | null;
-}
-
-export interface Workspace {
-  name: string;
-  panes: PaneNode[];
-  activePaneId: string;
-}
-
-function pane(surface: SurfaceKind, nodeId: string | null = null): PaneNode {
-  return { id: surface, surface, nodeId };
-}
-
-export function workspacePanes(ws: Workspace): PaneNode[] {
-  return ws.panes;
-}
-
-export function findPane(panes: PaneNode[], id: string): PaneNode | null {
-  return panes.find((item) => item.id === id) ?? null;
-}
-
-export function focusNext(ws: Workspace, dir: 1 | -1): Workspace {
-  if (ws.panes.length <= 1) return ws;
-  const index = ws.panes.findIndex((item) => item.id === ws.activePaneId);
-  const next = ws.panes[(index + dir + ws.panes.length) % ws.panes.length];
-  return next ? { ...ws, activePaneId: next.id } : ws;
-}
-
-/** The only layout: four equal-width read-only surfaces. */
-export function defaultWorkspace(model: GraphModel): Workspace {
-  const panes = [
-    pane("explore", graphRoots(model)[0] ?? null),
-    pane("detail"),
-    pane("focus"),
-    pane("health"),
-  ];
-  return { name: "Explore", panes, activePaneId: panes[0]!.id };
-}
-
-/** Hide inactive panes in a narrow terminal. */
-export function collapseForWidth(ws: Workspace, width: number): Workspace {
-  if (width >= 80) return ws;
-  const active = findPane(ws.panes, ws.activePaneId);
-  return active ? { ...ws, panes: [active] } : ws;
-}

package/src/pi/viewer/tui/workspaceRoot.ts

@@ -1,389 +0,0 @@
-/**
- * workspaceRoot.ts — the v2 workspace ROOT component (weave-view-tui-v2 §4, §7).
- *
- * Sits above the pure fixed `workspace.ts` model and the `surface/*`
- * components. It composes panes from a `Workspace` value into a real pi-tui
- * tree (HStack/Pane), owns the single input listener, routes keys and
- * cross-pane SurfaceEvents, renders the
- * branded header + footer + narrow-mode tab bar (§9.2, decision 5), and
- * applies responsive collapse.
- *
- * It is drivable with a fake tui/theme/loaders and is the path wired in run.ts.
- */
-
-import { HStack, matchesKey, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
-import { BodyStore } from "./bodyStore";
-import { renderMark } from "./branding";
-import type { WeaveLoaders, WeaveTheme, WeaveTui } from "./surface/base";
-import { countProvenance } from "./model";
-import type { GraphModel, GraphNode } from "../../../core/graph/model";
-import { Pane } from "./surface/base";
-import type { Surface, SurfaceEvent, SurfaceContext } from "./surface/base";
-import { ExploreSurface } from "./surface/explore";
-import { bindDetail, DetailSurface } from "./surface/detail";
-import { FocusSurface } from "./surface/focus";
-import { HealthSurface } from "./surface/health";
-import { collapseForWidth, defaultWorkspace, focusNext, workspacePanes, type PaneNode, type Workspace } from "./workspace";
-
-export interface WeaveWorkspaceOptions {
-  model: GraphModel;
-  theme: WeaveTheme;
-  tui: WeaveTui;
-  loaders: WeaveLoaders;
-  done: (result: null) => void;
-  rows?: number;
-  now?: () => number;
-}
-
-/** Decode the few root-level keys; all other input belongs to the active surface. */
-export function decodeWorkspaceKey(data: string): string | null {
-  if (data === "?") return "help";
-  if (data === "q") return "quit";
-  if (data === "r") return "refresh";
-  return null;
-}
-
-export class WeaveWorkspace implements Component {
-  model: GraphModel;
-  private readonly theme: WeaveTheme;
-  private readonly tui: WeaveTui;
-  private readonly loaders: WeaveLoaders;
-  private readonly done: (result: null) => void;
-  private readonly rows: number;
-  private readonly nowFn: () => number;
-  private readonly logo: string;
-  private readonly bodies: BodyStore;
-  private ctx: SurfaceContext;
-  /** paneId → surface instance. */
-  private panes = new Map<string, Surface>();
-  /** The fixed pane layout + focus. */
-  workspace: Workspace;
-  private helpOpen = false;
-  refreshing = false;
-  private quitted = false;
-  private renderCache = new Map<string, string[]>();
-  wantsKeyRelease = false;
-
-  constructor(opts: WeaveWorkspaceOptions) {
-    this.model = opts.model;
-    this.theme = opts.theme;
-    this.tui = opts.tui;
-    this.loaders = opts.loaders;
-    this.done = opts.done;
-    this.rows = opts.rows ?? 24;
-    this.nowFn = opts.now ?? Date.now;
-    this.logo = renderMark(opts.theme, 20);
-    this.bodies = new BodyStore({
-      loaders: opts.loaders,
-      onChange: () => this.invalidateAndRender(),
-    });
-    this.ctx = {
-      model: opts.model,
-      theme: opts.theme,
-      loaders: opts.loaders,
-      bodies: this.bodies,
-      now: this.nowFn,
-    };
-    this.workspace = defaultWorkspace(opts.model);
-    this.syncPanes();
-  }
-
-  invalidate(): void {
-    this.renderCache.clear();
-    for (const s of this.panes.values()) s.invalidate();
-  }
-
-  private invalidateAndRender(): void {
-    this.invalidate();
-    this.tui.requestRender();
-  }
-
-  setModel(model: GraphModel): void {
-    this.model = model;
-    // Surfaces read the model through the shared context (this.ctx.model), not
-    // this.model — so a refresh that only swaps this.model leaves every pane
-    // showing the pre-refresh graph. Propagate to the context so `r` actually
-    // re-renders the body, then drop stale pane selections that no longer exist.
-    this.ctx.model = model;
-    for (const s of this.panes.values()) s.rebind?.(model);
-    this.bodies.clear();
-    this.refreshing = false;
-    this.invalidateAndRender();
-  }
-
-  /** Rebuild surface instances so every pane node in the tree has one. */
-  private syncPanes(): void {
-    const wanted = workspacePanes(this.workspace);
-    const next = new Map<string, Surface>();
-    for (const pn of wanted) {
-      let s = this.panes.get(pn.id);
-      if (!s) s = this.createSurface(pn);
-      next.set(pn.id, s);
-    }
-    this.panes = next;
-  }
-
-  private createSurface(pn: PaneNode): Surface {
-    const init = { context: this.ctx, onEvent: (e: SurfaceEvent) => this.onSurfaceEvent(e) };
-    switch (pn.surface) {
-      case "explore":
-        return new ExploreSurface(init);
-      case "detail":
-        return pn.nodeId ? bindDetail(init, pn.nodeId) : new DetailSurface(init);
-      case "focus": {
-        const f = new FocusSurface(init);
-        if (pn.nodeId) f.setFocus(pn.nodeId);
-        return f;
-      }
-      case "health":
-        return new HealthSurface(init);
-    }
-  }
-
-  handleInput(data: string): void {
-    if (matchesKey(data, "tab")) return this.cycleFocus(1);
-    if (matchesKey(data, "shift+tab")) return this.cycleFocus(-1);
-    if (matchesKey(data, "escape")) {
-      // Esc precedence (mirrors v1): if the active pane is in a sub-mode
-      // (Explore search OR Detail goto-line), Esc clears it; otherwise Esc
-      // quits the explorer.
-      const active = this.activePane();
-      if (active && inSubMode(active)) {
-        active.handleInput?.(data);
-        this.invalidate();
-        this.tui.requestRender();
-        return;
-      }
-      this.quit();
-      return;
-    }
-    const wsKey = decodeWorkspaceKey(data);
-    if (wsKey) {
-      this.applyWorkspaceKey(wsKey);
-      return;
-    }
-    const active = this.activePane();
-    if (active?.handleInput) {
-      active.handleInput(data);
-      // CRITICAL: the surface updated its own selection/scroll state, but it
-      // has no `tui` and the workspace render cache is now stale. Invalidate
-      // (clears the workspace + per-surface caches) and request a fresh render
-      // — without this, arrow/enter/filter keys change state but the screen
-      // never updates (the "arrows don't navigate" bug).
-      this.invalidate();
-      this.tui.requestRender();
-    }
-  }
-
-  private quit(): void {
-    if (!this.quitted) {
-      this.quitted = true;
-      this.done(null);
-    }
-  }
-
-  private applyWorkspaceKey(key: string): void {
-    switch (key) {
-      case "quit":
-        this.quit();
-        return;
-      case "refresh":
-        if (this.refreshing) return;
-        this.refreshing = true;
-        this.invalidateAndRender();
-        void this.loaders
-          .rebuild()
-          .then((m) => this.setModel(m))
-          .catch(() => {
-            this.refreshing = false;
-            this.invalidateAndRender();
-          });
-        return;
-      case "help":
-        this.helpOpen = !this.helpOpen;
-        this.invalidateAndRender();
-        return;
-    }
-  }
-
-  private cycleFocus(dir: 1 | -1): void {
-    this.workspace = focusNext(this.workspace, dir);
-    this.refreshFocusFlags();
-    this.invalidateAndRender();
-  }
-
-  private refreshFocusFlags(): void {
-    for (const pn of workspacePanes(this.workspace)) {
-      const s = this.panes.get(pn.id);
-      s?.setFocused(pn.id === this.workspace.activePaneId);
-    }
-  }
-
-  private setActive(paneId: string): void {
-    this.workspace = { ...this.workspace, activePaneId: paneId };
-    this.refreshFocusFlags();
-  }
-
-  private activePane(): Surface | undefined {
-    return this.panes.get(this.workspace.activePaneId);
-  }
-
-  private onSurfaceEvent(e: SurfaceEvent): void {
-    if (e.type === "openEditor") {
-      this.openInEditor(e.id);
-      return;
-    }
-    if (e.type === "openDetail") {
-      this.openDetail(e.id);
-      return;
-    }
-    if (e.type === "focusNode") {
-      this.openFocus(e.id);
-    }
-  }
-
-  private openInEditor(id: string): void {
-    const node = this.model.nodes.find((n) => n.id === id);
-    if (!node || node.kind !== "note") return;
-    if (node.detail.slug) void this.loaders.openNote(node.detail.slug);
-  }
-
-  /** Open a selected node in the fixed Detail pane. */
-  private openDetail(id: string): void {
-    // (The active Detail surface already rebinds itself on enter, so no
-    // active-pane special case is needed here.)
-    const panes = workspacePanes(this.workspace);
-    const detail = panes.find((p) => p.surface === "detail");
-    if (!detail) return;
-    this.bindDetail(detail.id, id);
-    this.setActive(detail.id);
-  }
-
-  private bindDetail(paneId: string, id: string): void {
-    const s = this.panes.get(paneId) as DetailSurface;
-    if (!s) return;
-    s.state = { nodeId: id, selectedId: id, scrollOffset: 0 };
-    this.requestBody(id);
-    this.invalidateAndRender();
-  }
-
-  private openFocus(id: string): void {
-    const active = this.activePane();
-    if (active && active.kind === "focus") {
-      (active as FocusSurface).setFocus(id);
-      this.invalidateAndRender();
-      return;
-    }
-    const panes = workspacePanes(this.workspace);
-    const focus = panes.find((p) => p.surface === "focus");
-    if (focus) {
-      (this.panes.get(focus.id) as FocusSurface).setFocus(id);
-      this.setActive(focus.id);
-      this.invalidateAndRender();
-    }
-  }
-
-  private requestBody(id: string): void {
-    const node = this.model.nodes.find((n) => n.id === id);
-    if (!node) return;
-    if (node.kind === "note") this.bodies.load(id, "note", node.detail.slug);
-    else if (node.kind === "file") this.bodies.load(id, "file", node.detail.path);
-  }
-
-  render(width: number): string[] {
-    const key = `${width}:${this.workspace.activePaneId}:${this.helpOpen}:${this.refreshing}`;
-    const cached = this.renderCache.get(key);
-    if (cached) return cached;
-    const out: string[] = [];
-    out.push(...this.renderHeader(width));
-    out.push(...this.renderBody(width));
-    if (width < 80) out.push(...this.renderTabBar(width));
-    out.push(...this.renderFooter(width));
-    const clamped = out.slice(0, Math.max(1, this.rows)).map((l) => (visibleWidth(l) > width ? truncateToWidth(l, width) : l));
-    this.renderCache.set(key, clamped);
-    return clamped;
-  }
-
-  private renderHeader(width: number): string[] {
-    const t = this.theme;
-    const counts = countProvenance(this.model.nodes);
-    const repo = this.model.nodes.find((n) => n.kind === "repository");
-    const repoState = repoStaleness(this.model, repo);
-    const repoPart = repo ? ` · repo ${repo.label}:${repoState}` : "";
-    const mark = this.logo;
-    const head = `${mark}${mark ? " " : ""}${t.bold("weave view")}`;
-    const fill = "─".repeat(Math.max(1, width - visibleWidth(head) - 2));
-    const line1 = `${head} ${fill} ${this.workspace.name} · ${workspacePanes(this.workspace).length} panes${repoPart}`;
-    const out: string[] = [truncateToWidth(line1, width)];
-    const banner = this.bannerText();
-    if (banner) out.push(t.fg("warning", truncateToWidth(banner, width)));
-    const countsLine = `notes ${counts.total} (● ${counts.human} / ◐ ${counts.agent} / ○ ${counts.generated})`;
-    out.push(truncateToWidth(t.fg("dim", countsLine), width));
-    return out;
-  }
-
-  private bannerText(): string | null {
-    return this.refreshing ? "refreshing…" : null;
-  }
-
-  private renderBody(width: number): string[] {
-    const effective = collapseForWidth(this.workspace, width);
-    const bodyRows = Math.max(1, this.rows - 4);
-    const stack = new HStack();
-    for (const pane of effective.panes) stack.addChild(this.buildPane(pane, bodyRows), { grow: 1 });
-    return stack.render(width);
-  }
-
-  private buildPane(node: PaneNode, rows: number): Component {
-    const s = this.panes.get(node.id);
-    if (!s) return { render: () => [], invalidate: () => {} };
-    (s as { paneRows?: number }).paneRows = Math.max(1, rows - 3);
-    const p = new Pane(s, this.theme);
-    p.rows = rows;
-    p.setFocused(node.id === this.workspace.activePaneId);
-    return p;
-  }
-
-  private renderTabBar(width: number): string[] {
-    const panes = workspacePanes(this.workspace);
-    const t = this.theme;
-    const parts = panes.map((p) => {
-      const active = p.id === this.workspace.activePaneId;
-      return active ? t.fg("accent", `[${p.surface}]`) : p.surface;
-    });
-    return [truncateToWidth(parts.join("  "), width)];
-  }
-
-  private renderFooter(width: number): string[] {
-    const t = this.theme;
-    if (this.helpOpen) {
-      const help = [
-        "Tab focus · ↑↓/jk move · ←→/hl expand · enter open · f focus · r refresh · ? help · q quit",
-        "↑↓/jk move · ←→/hl expand · enter open · / filter · p prov · f focus · r refresh · ? help · q quit",
-      ];
-      return help.map((l) => t.fg("dim", truncateToWidth(l, width)));
-    }
-    const hint = "Tab focus · ↑↓/jk move · ←→/hl expand · enter open · f focus · r refresh · ? help · q quit";
-    return [t.fg("dim", truncateToWidth(hint, width))];
-  }
-}
-
-/** True when the active surface is in a sub-mode that Esc should clear instead
- *  of quitting — Explore's search (`state.searching`) or Detail's goto-line
- *  (`state.gotoBuf`). Surfaces own their own state; read defensively so a
- *  surface without either field simply returns false. */
-function inSubMode(s: Surface | undefined): boolean {
-  const st = (s as { state?: { searching?: boolean; gotoBuf?: string | null } }).state;
-  return !!st && (st.searching === true || st.gotoBuf != null);
-}
-
-function repoStaleness(model: GraphModel, repo: GraphNode | undefined): string {
-  if (repo) {
-    const st = model.staleness;
-    if (st && "state" in st) return st.state;
-    return "fresh";
-  }
-  return "missing";
-}
-
-export type { Component };