@visual-z/xeno 0.2.1 → 0.4.0

package/src/tui/tree.ts

@@ -1,471 +0,0 @@
-/**
- * Session-tree layout and selection. Pure: renderTree(nodes, selection,
- * width, style) → string[]. Collapse/filter/cursor never reach the log —
- * the thing that happened is rewind, and that already has an event.
- *
- * Connectors (`├─` / `└─` / `│`) are kept before prompt text when the
- * terminal is too narrow. A line that wraps would make the line-diff
- * renderer count one row where the screen used two (PLAYBOOK width rule;
- * same trap as toolview's `"  → "` prefix).
- */
-
-import { assertNever } from "./exhaustive.ts";
-import type { Key } from "./keys.ts";
-import type { Component } from "./text.ts";
-import { displayWidth } from "./width.ts";
-import { PLAIN_ATTRS, paint, type Style } from "./style.ts";
-import { Input } from "../vendor/pi-tui/components/input.ts";
-import { encodeKey } from "./input.ts";
-import { truncateToWidth } from "../vendor/pi-tui/utils.ts";
-import { getKeybindings } from "../vendor/pi-tui/keybindings.ts";
-
-/** Same mark /back uses for a branch the session rewound away from. */
-export const LEFT_BRANCH_MARK = "↩";
-
-/**
- * Why the live region is not a blank box. Named in the card: an empty
- * frame looks like a render bug, and there is a real reason (no completed
- * exchange to jump to).
- */
-export const EMPTY_TREE_MESSAGE = "nothing to go back to -- no exchange has completed yet";
-
-/** Filter toggle lives here so the key is not a hidden chord. */
-export const TREE_HINT = "tab user/all · enter jump · esc cancel";
-
-const BRANCH_MID = "├─ ";
-const BRANCH_END = "└─ ";
-const PIPE = "│  ";
-const BLANK = "   ";
-const SELECTED = "→ ";
-const UNSELECTED = "  ";
-const CURRENT_MARK = "● ";
-const ON_PATH_MARK = "  ";
-const LEFT_MARK = `${LEFT_BRANCH_MARK} `;
-
-export type TreeKind = "user" | "other";
-export type TreeFilter = "user" | "default" | "no-tools" | "user-only" | "labeled-only" | "all";
-
-export interface TreeNode {
-  readonly id: string;
-  readonly prompt: string;
-  readonly onPath: boolean;
-  readonly current: boolean;
-  readonly kind: TreeKind;
-  readonly children: readonly TreeNode[];
-  readonly category?: "tool" | "message" | "metadata";
-  readonly label?: string;
-  readonly labelAt?: string;
-  readonly at?: string;
-  readonly content?: string;
-  /** Exact event position; user messages navigate before themselves. */
-  readonly target?: string;
-}
-
-export interface TreeSelection {
-  readonly index: number;
-  readonly filter: TreeFilter;
-}
-
-export interface TreeState {
-  readonly nodes: readonly TreeNode[];
-  readonly selected: number;
-  readonly filter: TreeFilter;
-  readonly confirmed: TreeNode | null;
-  readonly cancelled: boolean;
-}
-
-export interface CreateTreeOptions {
-  readonly filter?: TreeFilter;
-  readonly style?: Style;
-  readonly bindings?: Readonly<Record<string, readonly string[]>>;
-}
-
-/**
- * A restore point as the log already knows it. parent pointers are a
- * separate map so this file never imports store.
- */
-export interface TreePoint {
-  readonly node: number;
-  readonly atEvent: string;
-  readonly prompt: string;
-  readonly onPath: boolean;
-  readonly kind?: TreeKind;
-  readonly category?: "tool" | "message" | "metadata";
-  readonly label?: string;
-  readonly labelAt?: string;
-  readonly at?: string;
-  readonly content?: string;
-  readonly target?: string;
-}
-
-export type NodeParent = { readonly node: number; readonly at_event?: string } | null;
-
-export function createTree(
-  nodes: readonly TreeNode[],
-  opts: CreateTreeOptions = {},
-): TreeState {
-  return {
-    nodes,
-    selected: 0,
-    filter: opts.filter ?? "all",
-    confirmed: null,
-    cancelled: false,
-  };
-}
-
-export function applyTreeKey(state: TreeState, key: Key): TreeState {
-  switch (key.type) {
-    case "up":
-      return move(state, -1);
-    case "down":
-      return move(state, 1);
-    case "enter":
-      return confirm(state);
-    case "escape":
-      return { ...state, cancelled: true, confirmed: null };
-    case "tab":
-      return toggleFilter(state);
-    case "char":
-    case "backspace":
-    case "delete":
-    case "left":
-    case "right":
-    case "home":
-    case "end":
-    case "pageup":
-    case "pagedown":
-    case "ctrl":
-    case "alt":
-      return state;
-    default:
-      return assertNever(key, "applyTreeKey");
-  }
-}
-
-function visibleNodes(nodes: readonly TreeNode[], filter: TreeFilter): TreeNode[] {
-  if (filter === "all") return [...nodes];
-  const out: TreeNode[] = [];
-  const stack = [...nodes].reverse().map(node => ({ node, into: out }));
-  while (stack.length) {
-    const { node: n, into } = stack.pop()!;
-    const include = filter === "user" || filter === "user-only" ? n.kind === "user" :
-      filter === "labeled-only" ? Boolean(n.label) : filter === "no-tools" ? n.category !== "tool" && n.category !== "metadata" : n.category !== "metadata";
-    const children: TreeNode[] = [];
-    if (include) into.push({ ...n, children });
-    for (let i = n.children.length - 1; i >= 0; i--) stack.push({ node: n.children[i]!, into: include ? children : into });
-  }
-  return out;
-}
-
-function flatten(nodes: readonly TreeNode[]): TreeNode[] {
-  const out: TreeNode[] = [];
-  const stack = [...nodes].reverse();
-  while (stack.length) {
-    const n = stack.pop()!;
-    out.push(n);
-    for (let i = n.children.length - 1; i >= 0; i--) stack.push(n.children[i]!);
-  }
-  return out;
-}
-
-function move(state: TreeState, dir: -1 | 1): TreeState {
-  const n = flatten(visibleNodes(state.nodes, state.filter)).length;
-  if (n === 0) return state;
-  const selected = (state.selected + dir + n) % n;
-  return { ...state, selected, confirmed: null, cancelled: false };
-}
-
-function confirm(state: TreeState): TreeState {
-  const item = flatten(visibleNodes(state.nodes, state.filter))[state.selected];
-  if (item === undefined) return state;
-  return { ...state, confirmed: item, cancelled: false };
-}
-
-function toggleFilter(state: TreeState): TreeState {
-  const filter: TreeFilter = state.filter === "all" || state.filter === "default" ? "user" : "all";
-  const n = flatten(visibleNodes(state.nodes, filter)).length;
-  const selected = n === 0 ? 0 : Math.min(state.selected, n - 1);
-  return { ...state, filter, selected, confirmed: null, cancelled: false };
-}
-
-/**
- * Truncate on display columns. Slicing with s.length would cut a CJK
- * prompt in half and the next cell would paint garbage.
- */
-function truncate(s: string, width: number): string {
-  if (width <= 0) return "";
-  if (displayWidth(s) <= width) return s;
-  let out = "";
-  let w = 0;
-  for (const ch of s) {
-    const cw = displayWidth(ch);
-    if (w + cw > width) break;
-    out += ch;
-    w += cw;
-  }
-  return out;
-}
-
-export function renderTree(
-  nodes: readonly TreeNode[],
-  selection: TreeSelection,
-  width: number,
-  style?: Style,
-): string[] {
-  const w = Math.max(0, Math.floor(width));
-  const filtered = visibleNodes(nodes, selection.filter);
-  if (filtered.length === 0) {
-    return [truncate(EMPTY_TREE_MESSAGE, w)];
-  }
-
-  const flat = flatten(filtered);
-  const selected = flat[selection.index] ?? flat[0];
-  const selectedId = selected?.id;
-  const lines: string[] = [];
-  walk(filtered, "", true, selectedId, w, style, lines);
-  const hint = truncate(TREE_HINT, w);
-  if (hint.length > 0) {
-    lines.push(style !== undefined ? paint(hint, { ...PLAIN_ATTRS, dim: true }, style) : hint);
-  }
-  return lines;
-}
-
-function walk(
-  nodes: readonly TreeNode[],
-  prefix: string,
-  isRoot: boolean,
-  selectedId: string | undefined,
-  width: number,
-  style: Style | undefined,
-  lines: string[],
-): void {
-  const stack = nodes.map((node, i) => ({ node, prefix, root: isRoot, last: i === nodes.length - 1 })).reverse();
-  while (stack.length) {
-    const { node, prefix: indent, root, last } = stack.pop()!;
-    const branch = root ? "" : last ? BRANCH_END : BRANCH_MID;
-    const sel = node.id === selectedId ? SELECTED : UNSELECTED;
-    const mark = node.current ? CURRENT_MARK : node.onPath ? ON_PATH_MARK : LEFT_MARK;
-    // Left-to-right: connectors stay, prompt is what width drops first.
-    const raw = sel + indent + branch + mark + (node.label ? `[${node.label}] ` : "") + node.prompt;
-    const clipped = truncate(raw, width);
-    const chosen = node.id === selectedId;
-    lines.push(
-      chosen && style !== undefined
-        ? paint(clipped, { ...PLAIN_ATTRS, selected: true }, style)
-        : clipped,
-    );
-    const nextPrefix = root ? "" : indent + (last ? BLANK : PIPE);
-    // Bound indentation to the display, independently of history depth.
-    const budget = Math.max(3, Math.min(30, width - 20));
-    const childPrefix = nextPrefix.length > budget ? "… " + nextPrefix.slice(-(budget - 2)) : nextPrefix;
-    for (let i = node.children.length - 1; i >= 0; i--) stack.push({ node: node.children[i]!, prefix: childPrefix, root: false, last: i === node.children.length - 1 });
-  }
-}
-
-/**
- * Restore points plus parent pointers → the tree the view paints.
- *
- * Same-node exchanges stay a chain. A child node whose parent.at_event
- * matches a point hangs off that point as a sibling of the continuation,
- * which is how a rewind becomes a visible fork instead of a missing row.
- */
-export function treeFromPoints(
-  points: readonly TreePoint[],
-  parents: ReadonlyMap<number, NodeParent>,
-  currentNode: number,
-): TreeNode[] {
-  const byNode = new Map<number, TreePoint[]>();
-  for (const p of points) {
-    const list = byNode.get(p.node) ?? [];
-    list.push(p);
-    byNode.set(p.node, list);
-  }
-
-  const lastHere = [...points].reverse().find((p) => p.onPath && p.node === currentNode);
-  const lastOnPath = lastHere ?? [...points].reverse().find((p) => p.onPath);
-
-  function toNode(p: TreePoint, children: readonly TreeNode[]): TreeNode {
-    return {
-      ...p,
-      id: `${p.node}:${p.atEvent}`,
-      prompt: p.prompt,
-      onPath: p.onPath,
-      current: lastOnPath !== undefined && lastOnPath.node === p.node && lastOnPath.atEvent === p.atEvent,
-      kind: p.kind ?? "user",
-      children,
-    };
-  }
-
-  // Wire event chains and branch edges separately. Recursing once per event
-  // overflows the JS stack on otherwise valid long sessions.
-  type MutableNode = TreeNode & { children: TreeNode[] };
-  const chains = new Map<number, MutableNode[]>();
-  const events = new Map<string, MutableNode>();
-  for (const [id, pts] of byNode) {
-    const nodes = pts.map(p => toNode(p, []) as MutableNode);
-    for (let i = 0; i < nodes.length; i++) {
-      events.set(nodes[i]!.id, nodes[i]!);
-      if (nodes[i + 1]) nodes[i]!.children.push(nodes[i + 1]!);
-    }
-    chains.set(id, nodes);
-  }
-  const forest: TreeNode[] = [];
-  for (const [id, nodes] of [...chains].sort(([a], [b]) => a - b)) {
-    const first = nodes[0];
-    if (!first) continue;
-    let parent = parents.get(id);
-    const visited = new Set<number>([id]);
-    while (parent && !chains.get(parent.node)?.length && !visited.has(parent.node)) {
-      visited.add(parent.node); parent = parents.get(parent.node);
-    }
-    const anchor = parent && !visited.has(parent.node) ? events.get(`${parent.node}:${parent.at_event}`) ?? chains.get(parent.node)?.at(-1) : undefined;
-    if (anchor) anchor.children.push(first); else forest.push(first);
-  }
-  return forest;
-}
-
-export class TreeList implements Component {
-  private current: TreeState;
-  private style: Style | undefined;
-  private readonly bindings: Readonly<Record<string, readonly string[]>> | undefined;
-  private readonly search = new Input({ prompt: "Search tree: " });
-  private readonly folded = new Set<string>();
-  private labelEditor: { node: TreeNode; input: Input } | undefined;
-  labelChange: { target: string; text: string } | undefined;
-  copyText: string | undefined;
-  showTimestamps = false;
-  onInput: ((data: string) => void) | undefined;
-
-  constructor(nodes: readonly TreeNode[], opts: CreateTreeOptions = {}) {
-    this.current = createTree(nodes, opts);
-    this.style = opts.style;
-    this.bindings = opts.bindings;
-  }
-
-  get state(): TreeState {
-    return { ...this.current, nodes: this.filtered() };
-  }
-  get selectedNode(): TreeNode | undefined { return flatten(this.filtered())[this.current.selected]; }
-  setNodes(nodes: readonly TreeNode[]): void {
-    const id = this.selectedNode?.id;
-    this.current = { ...this.current, nodes, selected: 0 };
-    this.current = { ...this.current, selected: Math.max(0, flatten(this.filtered()).findIndex(node => node.id === id)) };
-  }
-
-  applyKey(key: Key): TreeState {
-    return this.acceptInput(encodeKey(key));
-  }
-
-  get focused(): boolean { return (this.labelEditor?.input ?? this.search).focused; }
-  set focused(value: boolean) { (this.labelEditor?.input ?? this.search).focused = value; }
-  setStyle(style: Style): void { this.style = style; }
-  invalidate(): void { this.search.invalidate(); }
-  handleInput(data: string): void { if (this.onInput) this.onInput(data); else this.acceptInput(data); }
-  private filtered(): readonly TreeNode[] {
-    const tokens = this.search.getValue().toLowerCase().trim().split(/\s+/).filter(Boolean);
-    const nodes = visibleNodes(this.current.nodes, this.current.filter);
-    if (tokens.length) return flatten(nodes).filter(node => tokens.every(token => `${node.content ?? node.prompt} ${node.label ?? ""}`.toLowerCase().includes(token))).map(node => ({ ...node, children: [] }));
-    const out: TreeNode[] = [];
-    const stack = [...nodes].reverse().map(node => ({ node, into: out }));
-    while (stack.length) {
-      const { node, into } = stack.pop()!;
-      const children: TreeNode[] = [];
-      into.push({ ...node, prompt: `${this.showTimestamps && node.labelAt ? `${node.labelAt} ` : ""}${this.folded.has(node.id) ? "▸ " : ""}${node.prompt}`, children });
-      if (!this.folded.has(node.id)) for (let i = node.children.length - 1; i >= 0; i--) stack.push({ node: node.children[i]!, into: children });
-    }
-    return out;
-  }
-  acceptInput(data: string, action?: string): TreeState {
-    this.current = { ...this.current, confirmed: null, cancelled: false };
-    this.labelChange = undefined; this.copyText = undefined;
-    const kb = getKeybindings();
-    if (this.labelEditor) {
-      if (kb.matches(data, "tui.select.cancel")) this.labelEditor = undefined;
-      else if (kb.matches(data, "tui.select.confirm")) {
-        this.labelChange = { target: this.labelEditor.node.target ?? this.labelEditor.node.id, text: this.labelEditor.input.getValue() };
-        this.labelEditor = undefined;
-      } else this.labelEditor.input.handleInput(data);
-      return this.state;
-    }
-    const filters: TreeFilter[] = ["default", "no-tools", "user-only", "labeled-only", "all"];
-    const filterByAction: Record<string, TreeFilter> = { "app.tree.filter.default": "default", "app.tree.filter.noTools": "no-tools",
-      "app.tree.filter.userOnly": "user-only", "app.tree.filter.labeledOnly": "labeled-only", "app.tree.filter.all": "all" };
-    const filter = action ? filterByAction[action] : undefined;
-    if (filter) { this.folded.clear(); this.current = { ...this.current, filter: this.current.filter === filter ? "default" : filter, selected: 0 }; return this.state; }
-    if (action === "app.tree.filter.cycleForward" || action === "app.tree.filter.cycleBackward") {
-      const index = Math.max(0, filters.indexOf(this.current.filter));
-      this.folded.clear();
-      this.current = { ...this.current, filter: filters[(index + (action.endsWith("Forward") ? 1 : 4)) % 5]!, selected: 0 }; return this.state;
-    }
-    if (action === "app.tree.toggleLabelTimestamp") { this.showTimestamps = !this.showTimestamps; return this.state; }
-    const selected = this.selectedNode;
-    if (action === "app.tree.editLabel") {
-      if (selected) { const input = new Input({ prompt: "Label: " }); input.setValue(selected.label ?? ""); input.focused = this.focused; this.labelEditor = { node: selected, input }; }
-      return this.state;
-    }
-    if (action === "app.message.copy") { this.copyText = selected?.content ?? selected?.prompt; return this.state; }
-    if (selected && (action === "app.tree.foldOrUp" || action === "app.tree.unfoldOrDown")) {
-      const flat = flatten(this.filtered());
-      const parentOf = new Map<string, TreeNode>();
-      for (const node of flat) for (const child of node.children) parentOf.set(child.id, node);
-      const parent = parentOf.get(selected.id);
-      if (action === "app.tree.foldOrUp") {
-        if (selected.children.length && (!parent || parent.children.length > 1) && !this.folded.has(selected.id)) this.folded.add(selected.id);
-        else {
-          let target = selected;
-          while (parentOf.has(target.id)) {
-            const ancestor = parentOf.get(target.id)!;
-            if (ancestor.children.length > 1 && target.id !== selected.id) break;
-            target = ancestor;
-          }
-          this.current = { ...this.current, selected: flat.findIndex(node => node.id === target.id) };
-        }
-      } else if (this.folded.delete(selected.id)) { /* Expand in place before moving to a child. */ }
-      else {
-        let target = selected;
-        while (target.children.length) { const branch = target.children.length > 1; target = target.children[0]!; if (branch) break; }
-        this.current = { ...this.current, selected: flat.findIndex(node => node.id === target.id) };
-      }
-      return this.state;
-    }
-    if (kb.matches(data, "tui.select.cancel")) {
-      if (this.search.getValue()) { this.search.setValue(""); this.folded.clear(); this.current = { ...this.current, selected: 0 }; }
-      else this.current = { ...this.current, cancelled: true };
-    }
-    else if (kb.matches(data, "tui.select.confirm")) this.current = { ...this.current, confirmed: selected ?? null };
-    else if (kb.matches(data, "tui.select.up") || kb.matches(data, "tui.select.down")) {
-      const size = flatten(this.filtered()).length;
-      this.current = { ...this.current, selected: size ? (this.current.selected + (kb.matches(data, "tui.select.up") ? -1 : 1) + size) % size : 0 };
-    } else if (kb.matches(data, "tui.input.tab")) this.current = toggleFilter(this.current);
-    else if (kb.matches(data, "tui.select.pageUp") || kb.matches(data, "tui.select.pageDown") || kb.matches(data, "tui.editor.cursorLeft") || kb.matches(data, "tui.editor.cursorRight")) {
-      this.current = { ...this.current, selected: Math.max(0, Math.min(flatten(this.filtered()).length - 1,
-        this.current.selected + (kb.matches(data, "tui.select.pageUp") || kb.matches(data, "tui.editor.cursorLeft") ? -10 : 10))) };
-    } else {
-      const before = this.search.getValue(); this.search.handleInput(data);
-      if (before !== this.search.getValue()) this.folded.clear();
-      this.current = { ...this.current, selected: 0 };
-    }
-    return this.state;
-  }
-
-  render(width: number): string[] {
-    if (width <= 0) return [""];
-    if (this.labelEditor) return ["Edit label · empty removes it", ...this.labelEditor.input.render(width),
-      `${getKeybindings().getKeys("tui.select.confirm").join("/")} save · ${getKeybindings().getKeys("tui.select.cancel").join("/")} cancel`].map(line => truncateToWidth(line, width, ""));
-    const body = renderTree(
-      this.filtered(),
-      { index: this.current.selected, filter: this.current.filter },
-      width,
-      this.style,
-    );
-    // This is a viewport, not a total result cap. Arrows/search can reach every row.
-    const start = Math.max(0, this.current.selected - 5);
-    const rows = body.slice(start, start + 10);
-    const hints = this.bindings ? [["app.tree.filter.cycleForward", "filters"], ["app.tree.foldOrUp", "branch"], ["app.tree.editLabel", "label"],
-      ["app.tree.toggleLabelTimestamp", "label time"], ["app.message.copy", "copy"], ["tui.select.cancel", "cancel"]]
-      .flatMap(([action, label]) => this.bindings![action!]?.length ? [`${this.bindings![action!]!.join("/")} ${label}`] : []).join(" · ") : TREE_HINT;
-    return ["Session tree · Select an event to navigate", ...this.search.render(width),
-      ...rows, `${this.current.filter} · ${hints}`]
-      .map((line) => truncateToWidth(line, width, ""));
-  }
-}

package/src/vendor/pi-tui/LICENSE.upstream

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Mario Zechner
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/src/vendor/pi-tui/UPSTREAM.json

@@ -1,50 +0,0 @@
-{
-  "commit": "02eed88fd8912e54a804ddebd409e2e4c08ac5ef",
-  "files": {
-    "alt-screen-search.ts": "2ed3821323723515523075ac143ce5e25fdcd7c7",
-    "autocomplete.ts": "3ff45bf17a5def8d0bdf81e9eb1af264f1c5f768",
-    "colors.ts": "070a261344e307988f45e7c86d1728db5a00b8f3",
-    "components/alt-screen-flash.ts": "e4b823cd2bdd54696895cac93807cc6fcddaddd4",
-    "components/box.ts": "7c880d9145eff2c26db7969937223bb3776acced",
-    "components/cancellable-loader.ts": "7822cb04219440703a9100e02679725b3326fa1c",
-    "components/editor.ts": "c7fda44eb8288a10f518791f931cff4fc36c62b5",
-    "components/h-stack.ts": "07f8f8ffd055789d69266152f62ee97390bacf01",
-    "components/image.ts": "91d68016aae5d292e22a3e892631b7ed53b13e64",
-    "components/input.ts": "1bc26453098639991c22515cc94fee89b53f289d",
-    "components/loader.ts": "0c59e73a83bb4bd9978818b16bf556da53f48123",
-    "components/markdown.ts": "30c40c1715dfc374687b538d447988a81feb237f",
-    "components/mouse-region.ts": "a77ded0c1e59167fe2f0643e87531b95ed9e544d",
-    "components/scroll-view.ts": "b8f8a51ff0f8f93aabce0df072ee29c5a47c82b3",
-    "components/select-list.ts": "f4f4354dd850939e2e84ea8ce8a755206d3e8e43",
-    "components/settings-list.ts": "b1b8366bf349b30a1d93073a4cc1d0e2bfa9dc8a",
-    "components/spacer.ts": "7abe1551ca79a17bbb03d6b62f3ec18c50274a75",
-    "components/stack.ts": "68bde0368455646144a1dd3942b56a48e9d4f45a",
-    "components/text.ts": "7a50e2721028d544f641ab5f66ef1b752ff6d1f7",
-    "components/truncated-text.ts": "c26b8892967a8462a8828cfed4ea572a73af1602",
-    "components/v-stack.ts": "ce7b9292d6dfd0981650a1cf927f223b926f9714",
-    "editor-component.ts": "595645033a074d17b8190b73709c2623d3e479b5",
-    "fuzzy.ts": "1b5352c1c592956ea614a2ec3630cb6f606ccd83",
-    "index.ts": "93fb8b72777a3a4f8423cf4e7d5f74b8dbd982f0",
-    "keybindings.ts": "d6afb5ec39642c098b7d95e10ab6b57568e514b4",
-    "keys.ts": "8b6f8a0a708cc9a1c9b795ff1ec9766c4209114b",
-    "kill-ring.ts": "2292f91aa36baa1bf762df2890bdbed8ca17eb19",
-    "latex.ts": "060fd052d820b42903896e53053614e1c578a995",
-    "layout-node.ts": "a3c06b24564efaa35321f190641a80e95ce7c7ab",
-    "layout.ts": "897c51de2ffbc4c543e87399eaa4e8b6421449ef",
-    "native-modifiers.ts": "8cdc60d484717431bd5f1577b36f189275aa06d3",
-    "native-module-path.ts": "b75117feb7384da268cfd7d3a8c8fc6af0aeb10e",
-    "native-platform.ts": "3a6580a445d8a816225ed824d30e48a93268a761",
-    "oklab.ts": "83ddda42fca5bcd485464c74029c2f3db7a5cc6d",
-    "stdin-buffer.ts": "cc10c61a55196eb90d9da3e1858e48cab27e925f",
-    "terminal-colors.ts": "6a972a95bb5c3c0de65657f4861cdb3ad3579c41",
-    "terminal-image.ts": "a84d22c575599c55e5ea96c528e641e54df8511c",
-    "terminal.ts": "cce2dd116ca55b2c9f3add30b080a395e8f1f4bb",
-    "tui-alt-screen.ts": "bf8affb13ba1d3625711268c8b6f0956c9e5d90e",
-    "tui-main-screen.ts": "c079dd776984b23f5e0b4a833ac5b67fb31ff337",
-    "tui.ts": "7968a9e792375b9e8701ca4dbe89d18735aa387b",
-    "undo-stack.ts": "5b9a7e9cee03a08b5d7ee637b92834a3a28d7fd2",
-    "utils.ts": "f537ad7e37dcf35db1259aa05d43f1b45bdef7c7",
-    "wheel-scroll.ts": "a6c0018bd4caa9b5bc197d05d548bfdca4036172",
-    "word-navigation.ts": "7c7eced2b6ac3ff5b49418824c3ac00a1f0204a3"
-  }
-}

package/src/vendor/pi-tui/VENDOR.md

@@ -1,25 +0,0 @@
-# Vendored: pi TUI
-
-Source: https://github.com/earendil-works/pi — `packages/tui/src`
-License: MIT (see `LICENSE.upstream`), Copyright (c) 2025 Mario Zechner
-Copied: 2026-09-30
-Commit: `02eed88fd8912e54a804ddebd409e2e4c08ac5ef`
-All 45 source files verified against upstream Git blob hashes in `UPSTREAM.json`.
-
-The application also follows coding-agent's CustomEditor, searchable model
-selector and interactive-mode composition. Those product behaviors are adapted
-in `src/tui/` and `src/apps/`; Pi's AgentSession is not imported. Its dark/light
-palette is mapped into `src/core/theme.ts` with attribution there.
-
-This directory is an **unmodified copy**. Do not patch it in place: upgrade
-by recopying from upstream. Behaviour changes belong in `src/tui/`, which
-adapts this to xeno and is the only thing allowed to import from here.
-
-`AGENTS.md` exempts `src/vendor/` from the import-shape and dependency
-checks, because those exist to keep *our* code's layering decidable and
-upstream organises its code its own way.
-
-Native sources and all six upstream prebuilt `.node` binaries are included
-under `native/`, verified by `native/UPSTREAM.json` at the same commit.
-The upstream resolver loads them directly; unavailable platform capabilities
-retain its optional fallback. No install script or startup download is required.