pi-weave 0.1.5 → 0.1.7

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

@@ -13,6 +13,7 @@
  */
 
 import { matchesKey, parseKey, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+import { BodyStore } from "./bodyStore";
 
 import type { GraphModel, GraphNode, NodeKind } from "../../../core/graph/model";
 import type { NoteSource } from "../../../core/types";
@@ -141,10 +142,8 @@ export class WeaveExplorer implements Component {
   private readonly nowFn: () => number;
 
   state: ExplorerState;
-  /** Cached note/okf bodies keyed by node id; null = not yet loaded. */
-  private bodyCache = new Map<string, string | null>();
-  /** In-flight body loads, keyed by node id. */
-  private bodyLoading = new Set<string>();
+  /** Shared note/okf body cache (dedup by node id, bust-on-refresh). */
+  private readonly bodies: BodyStore;
   /** Render cache keyed by `${width}:${version}`. */
   private renderCache = new Map<string, string[]>();
   wantsKeyRelease = false;
@@ -157,14 +156,21 @@ export class WeaveExplorer implements Component {
     this.done = opts.done;
     this.rows = opts.rows ?? 24;
     this.nowFn = opts.now ?? Date.now;
+    this.bodies = new BodyStore({
+      loaders: opts.loaders,
+      onChange: () => {
+        this.state = { ...this.state, version: this.state.version + 1 };
+        this.invalidate();
+        this.tui.requestRender();
+      },
+    });
     this.state = initialState(graphRoots(this.model));
   }
 
   /** Replace the graph (used by the `r` refresh). Preserves selection by id. */
   setModel(model: GraphModel): void {
     this.model = model;
-    this.bodyCache.clear();
-    this.bodyLoading.clear();
+    this.bodies.clear();
     this.state = reduce(this.state, { type: "refreshDone" });
     // Re-resolve selection: keep id if still present, else first root.
     if (this.state.selectedId && !this.nodeExists(this.state.selectedId)) {
@@ -504,31 +510,12 @@ export class WeaveExplorer implements Component {
   }
 
   private maybeLoadBody(id: string): void {
-    if (this.bodyCache.has(id) || this.bodyLoading.has(id)) return;
     const node = this.model.nodes.find((n) => n.id === id);
     if (!node) return;
     if (node.kind === "note") {
-      const slug = node.detail.slug;
-      if (!slug) return;
-      this.bodyLoading.add(id);
-      void this.loaders.loadNote(slug).then((note) => {
-        this.bodyCache.set(id, note?.body ?? null);
-        this.bodyLoading.delete(id);
-        this.state = { ...this.state, version: this.state.version + 1 };
-        this.invalidate();
-        this.tui.requestRender();
-      });
+      this.bodies.load(id, "note", node.detail.slug);
     } else if (node.kind === "file") {
-      const rel = node.detail.path;
-      if (!rel) return;
-      this.bodyLoading.add(id);
-      void this.loaders.loadOkf(rel).then((file) => {
-        this.bodyCache.set(id, file?.body ?? null);
-        this.bodyLoading.delete(id);
-        this.state = { ...this.state, version: this.state.version + 1 };
-        this.invalidate();
-        this.tui.requestRender();
-      });
+      this.bodies.load(id, "file", node.detail.path);
     }
   }
 
@@ -539,8 +526,8 @@ export class WeaveExplorer implements Component {
     // never completes (maybeLoadBody skips non-note/file kinds).
     const node = this.model.nodes.find((n) => n.id === id);
     if (!node || (node.kind !== "note" && node.kind !== "file")) return [];
-    if (this.bodyLoading.has(id)) return [this.theme.fg("dim", "(loading…)")];
-    const body = this.bodyCache.get(id);
+    if (this.bodies.isLoading(id)) return [this.theme.fg("dim", "(loading…)")];
+    const body = this.bodies.get(id);
     if (body === undefined) {
       // not yet requested — trigger a load (render is sync, so show placeholder)
       queueMicrotask(() => this.maybeLoadBody(id));

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

@@ -0,0 +1,60 @@
+/**
+ * openNote — open a vault note in the user's editor (weave-view tui).
+ *
+ * Lifted out of the old browser viewer's `server.ts` when the in-browser
+ * viewer was retired in favour of a pixi.js rewrite; the TUI's `openNote`
+ * loader is the only remaining caller. The slug is validated against the
+ * vault (traversal-safe) before any shell-out, so an unsafe or missing
+ * note never reaches the editor.
+ */
+
+import { execFile } from "node:child_process";
+import { platform } from "node:os";
+import { promisify } from "node:util";
+import { getNote, resolveNotePath } from "../../../core";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * The OS command used to open a note file in the user's editor. Respects
+ * $EDITOR / $VISUAL (which may carry args, e.g. "code --wait"); falls back
+ * to the platform default opener. `env` and `os` are injectable so the
+ * mapping is unit-testable on any host without stubbing globals.
+ */
+export function openNoteCommand(
+  notePath: string,
+  env: NodeJS.ProcessEnv = process.env,
+  os: NodeJS.Platform = platform(),
+): { command: string; args: string[] } {
+  const editor = (env.EDITOR || env.VISUAL || "").trim();
+  if (editor) {
+    // editor is a trimmed non-empty string, so split+filter always yields a
+    // first segment — assert it rather than leave a dead `?? ""` branch.
+    const parts = editor.split(/\s+/).filter(Boolean);
+    const command = parts[0] as string;
+    return { command, args: [...parts.slice(1), notePath] };
+  }
+  if (os === "darwin") return { command: "open", args: [notePath] };
+  if (os === "win32") return { command: "cmd", args: ["/c", "start", "", notePath] };
+  return { command: "xdg-open", args: [notePath] };
+}
+
+/**
+ * Open a note in the OS editor. The slug is validated against the vault
+ * (traversal-safe) before any shell-out; returns false when the note does
+ * not exist or the slug is unsafe.
+ */
+export async function openNoteInEditor(
+  vaultRoot: string,
+  slug: string,
+  openCommand: (notePath: string) => { command: string; args: string[] } = openNoteCommand,
+): Promise<boolean> {
+  const path = resolveNotePath(vaultRoot, slug);
+  if (path === null) return false; // traversal-safe
+  const note = await getNote(vaultRoot, slug);
+  if (note === null) return false;
+  const { command, args } = openCommand(path);
+  if (!command) return false;
+  await execFileAsync(command, args);
+  return true;
+}

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

@@ -17,8 +17,10 @@ import {
   resolveVaultRoot,
   type GraphModel,
 } from "../../../core";
-import { openNoteInEditor } from "../server";
-import { WeaveExplorer, type WeaveLoaders, type WeaveTheme, type WeaveTui } from "./explorer";
+import { openNoteInEditor } from "./openNote";
+import { bundledLogoImage, logoTier, renderMark } from "./branding";
+import { WeaveWorkspace } from "./workspaceRoot";
+import type { WeaveLoaders, WeaveTheme, WeaveTui } from "./explorer";
 import { getWorkspaceStatus, formatStatusLine } from "../../../core";
 
 /** Open the in-terminal knowledge explorer. Returns when the explorer closes. */
@@ -26,7 +28,7 @@ export async function runWeaveViewTui(ctx: ExtensionCommandContext): Promise<voi
   // Guard: the TUI needs an interactive terminal (design §2).
   if (!ctx.hasUI || ctx.mode !== "tui") {
     ctx.ui.notify(
-      "pi-weave: '/weave-view tui' needs an interactive terminal — run /weave-view for the browser viewer.",
+      "pi-weave: '/weave-view' needs an interactive terminal to open the in-terminal explorer.",
       "warning",
     );
     return;
@@ -45,13 +47,20 @@ export async function runWeaveViewTui(ctx: ExtensionCommandContext): Promise<voi
 
   await ctx.ui.custom(
     (tui, theme, _keybindings, done) => {
-      const explorer = new WeaveExplorer({
+      const tier = logoTier();
+      const logo = renderMark(tier, theme as unknown as WeaveTheme, 20);
+      // bundledLogoImage gates on Kitty support itself and returns null (glyph
+      // header) when unavailable.
+      const logoImage = bundledLogoImage(theme as unknown as WeaveTheme);
+      const explorer = new WeaveWorkspace({
         model,
         theme: theme as unknown as WeaveTheme,
         tui: tui as unknown as WeaveTui,
         loaders,
         done,
         rows: tui.terminal.rows,
+        logo,
+        logoImage,
       });
       return explorer;
     },

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

@@ -0,0 +1,182 @@
+/**
+ * surface/base.ts — the shared Pane<Surface> wrapper (weave-view-tui-v2 §6).
+ *
+ * A **Surface** is a harness-free, self-owned component: it holds its own
+ * selection/scroll/filter/expansion state, renders its lines, and handles its
+ * own keys. Surfaces share the GraphModel, BodyStore, and loaders via a
+ * `SurfaceContext`. A **Pane** is a `Component` that hosts a Surface inside a
+ * bordered Box with a title and a focus ring (accent when active, dim `line`
+ * when inactive — conveyed by border + a leading `◆`, not color alone, per
+ * §10).
+ *
+ * The pane owns scrolling via the injected scroll/offset on the surface; the
+ * workspace root routes input to the single active pane's surface.
+ */
+
+import { truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+import type { GraphModel } from "../../../../core/graph/model";
+import { BodyStore } from "../bodyStore";
+import type { WeaveLoaders, WeaveTheme } from "../explorer";
+import type { SurfaceKind } from "../workspace";
+import type { ThemeSlot } from "../theme";
+
+/** A cross-pane navigation request a surface emits (resolved by the root). */
+export type SurfaceEvent =
+  | { type: "openDetail"; id: string }
+  | { type: "focusNode"; id: string }
+  | { type: "openEditor"; id: string };
+
+/** A surface emits events (e.g. "open detail") that the workspace root resolves. */
+export type SurfaceEventHandler = (event: SurfaceEvent) => void;
+
+/** Shared, session-level deps every surface reads. */
+export interface SurfaceContext {
+  model: GraphModel;
+  theme: WeaveTheme;
+  loaders: WeaveLoaders;
+  bodies: BodyStore;
+  /** Reference clock (epoch ms); defaults to Date.now at the root. */
+  now: () => number;
+}
+
+/** A surface can also be constructed with a render callback (test seam). */
+export interface SurfaceInit {
+  context: SurfaceContext;
+  /** Emit a cross-pane navigation event. */
+  onEvent?: SurfaceEventHandler;
+}
+
+/** What a surface component must expose on top of the pi-tui Component contract. */
+export interface Surface extends Component {
+  /** The surface kind this hosts. */
+  readonly kind: SurfaceKind;
+  /** Called by the workspace root when focus moves to/from this surface. */
+  setFocused(focused: boolean): void;
+  /** The pane title (surface name), shown in the border. */
+  title(): string;
+  /**
+   * Called after a refresh rebuilds the model, so a surface bound to a node
+   * that no longer exists can rebind to a survivor instead of showing
+   * "(not found)". Optional — surfaces with no node binding omit it.
+   */
+  rebind?(model: GraphModel): void;
+}
+
+/** Minimal theme surface the pane chrome needs. */
+export interface PaneTheme {
+  fg(slot: ThemeSlot, text: string): string;
+  bold(text: string): string;
+}
+
+/** A selectable row within a rendered surface (mirrors model.SelectableRow). */
+export interface PaneRow {
+  id: string;
+  /** Node id a row jumps to on enter (links/backlinks/neighbors). */
+  target?: string;
+}
+
+/** The render result of a surface: lines plus the selectable rows. */
+export interface SurfaceRender {
+  lines: string[];
+  rows: PaneRow[];
+}
+
+/** A generic selectable, windowed body builder used by the surfaces. */
+export function windowLines(
+  lines: string[],
+  selLine: number,
+  scrollOffset: number,
+  window: number,
+  marker: (text: string) => string,
+): string[] {
+  const win = Math.max(1, window);
+  let offset = scrollOffset;
+  if (selLine >= 0) {
+    if (selLine < offset) offset = selLine;
+    else if (selLine >= offset + win) offset = selLine - win + 1;
+  }
+  offset = Math.max(0, Math.min(offset, Math.max(0, lines.length - win)));
+  const out: string[] = [];
+  const end = Math.min(lines.length, offset + win);
+  for (let i = offset; i < end; i++) {
+    const ln = lines[i]!;
+    out.push(i === selLine ? marker(ln) : `  ${ln}`);
+  }
+  return out;
+}
+
+/**
+ * Pane — a bordered Box hosting a Surface. Renders a title + focus ring on
+ * the first line, then the surface's (windowed) lines. This is the v1 single
+ * pane chrome lifted into a reusable wrapper; the workspace root instantiates
+ * one Pane per pane node.
+ */
+export class Pane implements Component {
+  private readonly surface: Surface;
+  private readonly theme: PaneTheme;
+  private readonly borderFn: (slot: ThemeSlot, text: string) => string;
+  /** Current viewport height in rows (for windowing). */
+  rows = 24;
+  focused = false;
+  private cacheKey = "";
+
+  constructor(
+    surface: Surface,
+    theme: PaneTheme,
+    // Bind through the theme object: a bare `theme.fg` default would detach
+    // `this`, so the real pi theme's `fg` (which reads `this.fgColors.get(...)`)
+    // would crash with "Cannot read properties of undefined (reading 'get')".
+    borderFn: (slot: ThemeSlot, text: string) => string = (slot, text) => theme.fg(slot, text),
+  ) {
+    this.surface = surface;
+    this.theme = theme;
+    this.borderFn = borderFn;
+  }
+
+  get surfaceComponent(): Surface {
+    return this.surface;
+  }
+
+  setFocused(focused: boolean): void {
+    this.focused = focused;
+    this.surface.setFocused(focused);
+  }
+
+  invalidate(): void {
+    this.cacheKey = "";
+    this.surface.invalidate();
+  }
+
+  render(width: number): string[] {
+    const inner = Math.max(2, width - 2);
+    // The surface already windows + selection-marks its own lines (each
+    // surface owns its scroll/selection state). The pane only wraps them in a
+    // border and PADS to fill its allocated height so the split looks clean —
+    // it must NOT re-window (that double-applies the indent/marker and corrupts
+    // the layout). Each body line is sliced/padded to `inner` so borders align.
+    const surfaceLines = this.surface.render(inner);
+    const title = this.surface.title();
+    const active = this.focused;
+    const borderSlot = active ? "accent" : "dim";
+    const marker = active ? "◆ " : "  ";
+    const titleText = `${marker}${title}  `;
+    const top = `${this.borderFn(borderSlot, "┌")}${this.borderFn("dim", "─".repeat(inner))}${this.borderFn(borderSlot, "┐")}`;
+    const titleVis = visibleWidth(titleText);
+    const titleLine = `${this.borderFn(borderSlot, "│")}${this.theme.bold(titleText)}${" ".repeat(Math.max(0, inner - titleVis))}${this.borderFn(borderSlot, "│")}`;
+    // top + title + bottom = 3 fixed lines; body fills the rest so both panes
+    // in a split render the same height.
+    const bodyRows = Math.max(0, this.rows - 3);
+    const out = [top, titleLine];
+    for (let i = 0; i < bodyRows; i++) {
+      const ln = surfaceLines[i] ?? "";
+      const slice = visibleWidth(ln) > inner ? truncateToWidth(ln, inner) : ln;
+      const pad = Math.max(0, inner - visibleWidth(slice));
+      out.push(`${this.borderFn(borderSlot, "│")}${slice}${" ".repeat(pad)}${this.borderFn(borderSlot, "│")}`);
+    }
+    const bottom = `${this.borderFn(borderSlot, "└")}${this.borderFn("dim", "─".repeat(inner))}${this.borderFn(borderSlot, "┘")}`;
+    out.push(bottom);
+    return out;
+  }
+}
+
+export type { Component, SurfaceKind };