@visual-z/xeno 0.2.1 → 0.4.0

package/src/apps/extension-ui.ts

@@ -1,330 +0,0 @@
-/** Pi extension UI ownership, bound to a single resource generation (D19). */
-import type { ExtensionRegistry, ExtensionToolResult, ExtensionToolRenderContext } from "../runtime/extensions.ts";
-import type { ExtensionUI, ExtensionComponent, ExtensionTheme, WidgetFactory, FooterFactory, EditorFactory, AutocompleteFactory, InputHandler, CustomOptions, DialogOptions } from "../runtime/extension-ui.ts";
-import type { Theme } from "../core/theme.ts";
-import { builtinTheme } from "../core/theme.ts";
-import type { ResourceIndex } from "../store/resource-index.ts";
-import { themeResourcePath } from "../store/resource-index.ts";
-import { discoverThemes, resolveTheme } from "../store/resources.ts";
-import { Container, Lines, PiText, identityEditorTheme, type InteractiveScreen } from "../tui/host.ts";
-import type { Editor } from "../tui/editor.ts";
-import { SelectList } from "../tui/select.ts";
-import { keyMatches } from "../tui/input.ts";
-import { Editor as PiEditor } from "../vendor/pi-tui/components/editor.ts";
-import { Input } from "../vendor/pi-tui/components/input.ts";
-import type { Component, OverlayHandle } from "../vendor/pi-tui/tui.ts";
-import type { KeybindingsManager } from "../vendor/pi-tui/keybindings.ts";
-import type { AutocompleteProvider } from "../vendor/pi-tui/autocomplete.ts";
-
-interface Host {
-  screen(): InteractiveScreen; editor: Editor; theme(): Theme; colored(): boolean;
-  bindings(): KeybindingsManager; branch(): string | null;
-  redraw(): void; refreshTranscript(): void; input(data: string): void; notify: ExtensionUI["notify"];
-  setTheme(theme: Theme): void; expanded(): boolean; expand(value: boolean): void;
-  cwd(): string; showImages(): boolean; outputPad(): number; saveTheme(name: string): void;
-}
-type Slot = { factory: WidgetFactory; component: OwnedComponent; below: boolean };
-type OwnedComponent = Component & { dispose(): void; focused?: boolean };
-type Dialog = { component?: OwnedComponent; raw?: ExtensionComponent; handle?: OverlayHandle; close(value?: unknown): void };
-
-export class ExtensionUiController {
-  readonly header = new Container();
-  readonly above = new Container();
-  readonly below = new Container();
-  readonly partials = new Container();
-  private partialComponents = new Map<string, OwnedComponent>();
-  private toolStates = new Map<string, Record<string, unknown>>();
-  private footer: OwnedComponent | undefined;
-  private headerSlot: Slot | undefined;
-  private footerFactory: FooterFactory | undefined;
-  private widgets = new Map<string, Slot>();
-  private statuses = new Map<string, string>();
-  private listeners = new Set<InputHandler>();
-  private branchListeners = new Set<() => void>();
-  private unlisten: (() => void) | undefined;
-  private unbind: (() => void) | undefined;
-  private unwatchTools: (() => void) | undefined;
-  private footerSubscriptions: (() => void)[] = [];
-  private editorFactory: EditorFactory | undefined;
-  private autocomplete: AutocompleteFactory[] = [];
-  private baseCompletion: AutocompleteProvider | undefined;
-  private themeCache = new Map<string, { theme: ExtensionTheme; path: string | undefined }>();
-  private registry: ExtensionRegistry | undefined;
-  private reported = new Set<string>();
-  private hasTitle = false;
-  private generation = 0;
-  private api: ExtensionUI;
-  private dialog: Dialog | undefined;
-  private pendingDialogs = new Set<() => void>();
-  private tail: Promise<unknown> = Promise.resolve();
-  private workingMessage: string | undefined;
-  private workingVisible = true;
-  private frames: string[] | undefined;
-  private frame = 0;
-  private interval = 80;
-  private timer: ReturnType<typeof setInterval> | undefined;
-  hiddenThinkingLabel: string | undefined;
-  private readonly host: Host;
-  constructor(host: Host) { this.host = host; this.host.editor.onComponentError = error => { this.editorFactory = undefined; this.report(error); }; this.api = this.createApi(); this.rebind(); }
-  get context(): ExtensionUI { return this.api; }
-  get modal(): Component | undefined { return this.dialog?.handle ? undefined : this.dialog?.component; }
-  get overlayFocused(): boolean { return this.dialog?.handle?.isFocused() ?? false; }
-  get customFooter(): Component | undefined { return this.footer; }
-  get status(): string { return [...this.statuses.values()].join(" · "); }
-  private report(error: unknown): void { const message = String(error); if (this.reported.has(message)) return; this.reported.add(message); this.host.notify(`Extension UI: ${message}`, "error"); }
-  private attempt<T>(fn: () => T): T | undefined { try { return fn(); } catch (error) { this.report(error); return undefined; } }
-
-  /** Errors are isolated at the component boundary, including errors thrown only during render. */
-  own(component: ExtensionComponent, fallback?: Component): OwnedComponent {
-    let failed = false, disposed = false;
-    const fail = (error: unknown) => { const report = !failed; failed = true; if (report) this.report(error); };
-    return {
-      render: width => { if (!failed) try { return component.render(width); } catch (error) { fail(error); } return fallback?.render(width) ?? []; },
-      invalidate: () => { if (!failed) try { component.invalidate?.(); } catch (error) { fail(error); } },
-      handleInput: data => { if (!failed) try { component.handleInput?.(data); } catch (error) { fail(error); } },
-      get focused() { return component.focused ?? false; }, set focused(value: boolean) { component.focused = value; },
-      dispose: () => { if (disposed) return; disposed = true; this.attempt(() => component.dispose?.()); },
-    };
-  }
-
-  async bind(registry: ExtensionRegistry | undefined, resources: ResourceIndex | undefined): Promise<void> {
-    if (registry === this.registry) return;
-    this.clear(); this.registry = registry; this.api = this.createApi();
-    this.unbind = registry?.onDispose(() => { this.clear(); this.registry = undefined; this.host.refreshTranscript(); });
-    this.unwatchTools = registry?.onToolUpdate((name, id, input, result) => {
-      const tool = registry.tools.get(name); if (!tool?.renderResult) return;
-      this.partialComponents.get(id)?.dispose();
-      this.partialComponents.set(id, this.renderTool(name, input, { text: result.content.filter(c => c.type === "text").map(c => c.text).join("\n"), ok: result.isError !== true, data: result.details }, this.host.expanded(), new Lines(() => []), new PiText(result.content.filter(c => c.type === "text").map(c => c.text).join("\n"), 0, 0), id, result));
-      this.partials.clear(); for (const component of this.partialComponents.values()) this.partials.addChild(component);
-      this.host.redraw();
-    });
-    const generation = this.generation, cache = new Map<string, { theme: ExtensionTheme; path: string | undefined }>();
-    for (const name of await discoverThemes(resources)) {
-      const path = resources ? themeResourcePath(resources, name) : undefined, errors: string[] = [];
-      const theme = await resolveTheme(path ?? name, errors);
-      if (!errors.length) cache.set(name, { theme: this.theme(theme), path });
-    }
-    if (generation === this.generation) this.themeCache = cache;
-    this.host.refreshTranscript();
-  }
-  private theme(theme = this.host.theme()): ExtensionTheme {
-    const ansi = (color: string) => this.host.colored() && theme.colors[color] ? `\x1b[${theme.colors[color]}m` : "";
-    const wrap = (open: string, text: string, close = "\x1b[0m") => open ? open + text + close : text;
-    const attr = (code: number, end: number) => (text: string) => wrap(this.host.colored() ? `\x1b[${code}m` : "", text, `\x1b[${end}m`);
-    return { ...theme, fg: (color, text) => wrap(ansi(color), text, "\x1b[39m"), bg: (color, text) => wrap(ansi(color), text, "\x1b[49m"),
-      bold: attr(1, 22), dim: attr(2, 22), italic: attr(3, 23), underline: attr(4, 24), inverse: attr(7, 27), strikethrough: attr(9, 29), getFgAnsi: ansi, getBgAnsi: ansi,
-      getColorMode: () => "truecolor", getThinkingBorderColor: level => text => wrap(ansi("thinking" + (level[0]?.toUpperCase() ?? "O") + level.slice(1)), text, "\x1b[39m"),
-      getBashModeBorderColor: () => text => wrap(ansi("bashMode"), text, "\x1b[39m") };
-  }
-
-  private createApi(): ExtensionUI {
-    const owner = this, generation = this.generation;
-    const api: ExtensionUI = {
-      notify: this.host.notify,
-      select: (title, choices, opts) => this.choose(title, choices, opts),
-      confirm: async (title, message, opts) => (await this.choose(`${title}\n${message}`, ["Yes", "No"], opts)) === "Yes",
-      input: (title, placeholder, opts) => this.textDialog(title, placeholder ?? "", false, opts),
-      editor: (title, prefill) => this.textDialog(title, prefill ?? "", true),
-      custom: (factory, opts) => this.custom(factory, opts),
-      onTerminalInput: handler => { this.listeners.add(handler); return () => this.listeners.delete(handler); },
-      setStatus: (key, text) => { if (text === undefined) this.statuses.delete(key); else this.statuses.set(key, text); this.host.redraw(); },
-      setWidget: (key, content, opts) => {
-        this.widgets.get(key)?.component.dispose(); this.widgets.delete(key);
-        if (content !== undefined) {
-          const factory: WidgetFactory = typeof content === "function" ? content : () => new PiText(content.join("\n"), 0, 0);
-          const component = this.attempt(() => factory(this.host.screen(), this.theme()));
-          if (component) this.widgets.set(key, { factory, component: this.own(component), below: opts?.placement === "belowEditor" });
-        }
-        this.mountWidgets(); this.host.redraw();
-      },
-      setHeader: factory => {
-        this.headerSlot?.component.dispose(); this.headerSlot = undefined; this.header.clear();
-        const component = factory && this.attempt(() => factory(this.host.screen(), this.theme()));
-        if (component) { this.headerSlot = { factory: factory!, component: this.own(component), below: false }; this.header.addChild(this.headerSlot.component); }
-        this.host.redraw();
-      },
-      setFooter: factory => {
-        this.footer?.dispose(); this.footer = undefined; this.footerFactory = factory;
-        for (const unsubscribe of this.footerSubscriptions.splice(0)) unsubscribe();
-        const component = factory && this.attempt(() => factory(this.host.screen(), this.theme(), {
-          getGitBranch: () => this.host.branch() ?? undefined, getExtensionStatuses: () => new Map(this.statuses),
-          onBranchChange: fn => { this.branchListeners.add(fn); const off = () => { this.branchListeners.delete(fn); }; this.footerSubscriptions.push(off); return off; },
-        }));
-        if (component) this.footer = this.own(component);
-        this.host.redraw();
-      },
-      setTitle: title => { this.hasTitle = true; this.host.screen().terminal.setTitle(title); },
-      setWorkingMessage: message => { this.workingMessage = message; this.host.redraw(); },
-      setWorkingVisible: visible => { this.workingVisible = visible; this.host.redraw(); },
-      setWorkingIndicator: options => { this.frames = options?.frames; this.interval = Math.max(16, options?.intervalMs ?? 80); this.frame = 0; clearInterval(this.timer); this.timer = undefined; this.host.redraw(); },
-      setHiddenThinkingLabel: label => { this.hiddenThinkingLabel = label; this.host.refreshTranscript(); this.host.redraw(); },
-      getEditorText: () => this.host.editor.state.text,
-      setEditorText: text => { this.host.editor.applyExternal(text); this.host.redraw(); },
-      pasteToEditor: text => { this.host.editor.acceptInput(`\x1b[200~${text}\x1b[201~`); this.host.redraw(); },
-      addAutocompleteProvider: factory => { this.autocomplete.push(factory); this.refreshCompletion(); },
-      setEditorComponent: factory => {
-        const component = factory && this.attempt(() => factory(this.host.screen(), identityEditorTheme(), this.host.bindings()));
-        if (factory && !component) return;
-        this.editorFactory = factory; this.host.editor.setComponent(component); this.host.redraw();
-      },
-      getEditorComponent: () => this.editorFactory,
-      get theme() { return owner.theme(); },
-      getAllThemes: () => [...this.themeCache].map(([name, value]) => ({ name, path: value.path })),
-      getTheme: name => this.themeCache.get(name)?.theme,
-      setTheme: name => {
-        const theme = typeof name === "string" ? this.themeCache.get(name)?.theme : name;
-        if (!theme || typeof theme.colors !== "object") return { success: false, error: `Unknown theme: ${String(name)}` };
-        this.host.setTheme(theme); if (typeof name === "string") this.host.saveTheme(name); return { success: true };
-      },
-      getToolsExpanded: () => this.host.expanded(), setToolsExpanded: value => { this.host.expand(value); this.host.redraw(); },
-    };
-    // An asynchronous extension from a disposed session must not mutate its successor's UI.
-    return new Proxy(api, { get(target, key, receiver) {
-      const value: unknown = Reflect.get(target, key, receiver);
-      return typeof value === "function" ? (...args: unknown[]) => generation === owner.generation ? Reflect.apply(value, target, args) : undefined : value;
-    } });
-  }
-
-  private mountWidgets(): void {
-    this.above.clear(); this.below.clear();
-    for (const slot of this.widgets.values()) (slot.below ? this.below : this.above).addChild(slot.component);
-  }
-  setCompletion(provider: AutocompleteProvider): void { this.baseCompletion = provider; this.refreshCompletion(); }
-  private refreshCompletion(): void {
-    if (!this.baseCompletion) return;
-    let provider: AutocompleteProvider = this.baseCompletion;
-    for (const factory of this.autocomplete) { const base: AutocompleteProvider = provider; provider = this.attempt(() => factory(base)) ?? base; }
-    this.host.editor.setAutocompleteProvider(provider);
-  }
-  filterInput(data: string): string | undefined {
-    for (const listener of this.listeners) { const value = data, result = this.attempt(() => listener(value)); if (result?.consume) return undefined; data = result?.data ?? data; }
-    return data;
-  }
-  acceptInput(data: string): boolean {
-    const dialog = this.dialog; if (!dialog || dialog.handle && !dialog.handle.isFocused()) return false;
-    if (keyMatches(data, "escape") || keyMatches(data, "ctrl+c")) dialog.close();
-    else this.attempt(() => dialog.raw?.handleInput?.(data));
-    this.host.redraw(); return true;
-  }
-  private choose(title: string, choices: string[], options?: DialogOptions): Promise<string | undefined> {
-    return this.custom<string | undefined>((_tui, _theme, _bindings, done) => {
-      const list = new SelectList(choices.map(value => ({ label: value, value })), { title, search: true });
-      return { render: width => list.render(width), invalidate: () => list.invalidate(), handleInput: data => { const state = list.acceptInput(data); if (state.confirmed) done(state.confirmed.value); else if (state.cancelled) done(undefined); } };
-    }, options);
-  }
-  private textDialog(title: string, value: string, multiline: boolean, options?: DialogOptions): Promise<string | undefined> {
-    return this.custom<string | undefined>((tui, _theme, _bindings, done) => {
-      const editor = multiline ? new PiEditor(tui, identityEditorTheme()) : new Input();
-      if (editor instanceof PiEditor) editor.setText(value);
-      editor.onSubmit = text => done(text); editor.focused = true;
-      return { render: width => [title,
-        ...(editor instanceof Input && !editor.getValue() && value ? [value] : []), ...editor.render(width)], invalidate: () => editor.invalidate(), handleInput: data => editor.handleInput(data) };
-    }, options);
-  }
-  private custom<T>(factory: Parameters<ExtensionUI["custom"]>[0], options?: CustomOptions): Promise<T> {
-    const generation = this.generation;
-    let resolve!: (result: T) => void;
-    const result = new Promise<T>(done => { resolve = done; });
-    let closed = false, timeout: ReturnType<typeof setTimeout> | undefined, tick: ReturnType<typeof setInterval> | undefined;
-    const cancel = () => dialog.close();
-    const dialog: Dialog = { close: value => {
-      if (closed) return; closed = true;
-      clearTimeout(timeout); clearInterval(tick); options?.signal?.removeEventListener("abort", cancel); this.pendingDialogs.delete(cancel);
-      dialog.handle?.hide(); dialog.component?.dispose();
-      if (this.dialog === dialog) this.dialog = undefined;
-      resolve(value as T); this.host.redraw();
-    } };
-    this.pendingDialogs.add(cancel);
-    options?.signal?.addEventListener("abort", cancel, { once: true });
-    if (options?.signal?.aborted) cancel();
-    const before = this.tail; this.tail = before.then(() => result);
-    void before.then(async () => {
-      if (closed || generation !== this.generation) return cancel();
-      this.dialog = dialog;
-      dialog.component = this.own(new PiText("Loading…", 0, 0)); this.host.redraw();
-      if (options?.timeout !== undefined) { timeout = setTimeout(cancel, Math.max(0, options.timeout)); tick = setInterval(() => this.host.redraw(), 200); }
-      try {
-        const component = await factory(this.host.screen(), this.theme(), this.host.bindings(), value => dialog.close(value));
-        if (closed || generation !== this.generation) { this.attempt(() => component.dispose?.()); return; }
-        dialog.component?.dispose(); dialog.raw = component;
-        const owner = this.own(component);
-        // Pi receives raw terminal input through this wrapper; the app loop remains its only dispatcher.
-        const deadline = options?.timeout === undefined ? undefined : Date.now() + options.timeout;
-        dialog.component = { ...owner, render: width => [...(deadline === undefined ? [] : [`${Math.max(0, Math.ceil((deadline - Date.now()) / 1000))}s remaining`]), ...owner.render(width)],
-          get focused() { return component.focused ?? false; }, set focused(value: boolean) { component.focused = value; }, handleInput: data => this.host.input(data) };
-        if (options?.overlay) {
-          dialog.handle = this.host.screen().showOverlay(dialog.component!, typeof options.overlayOptions === "function" ? options.overlayOptions() : options.overlayOptions);
-          options.onHandle?.({ ...dialog.handle, hide: cancel });
-        }
-        this.host.redraw();
-      } catch (error) { this.report(error); cancel(); }
-    });
-    return result;
-  }
-  working(active: boolean, fallback: string): string | undefined {
-    if (!active || !this.workingVisible) { clearInterval(this.timer); this.timer = undefined; return undefined; }
-    const frames = this.frames ?? ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-    if (frames.length > 1 && !this.timer) { this.timer = setInterval(() => { this.frame++; this.host.redraw(); }, this.interval); this.timer.unref(); }
-    return `${frames.length ? frames[this.frame % frames.length] + " " : ""}${this.workingMessage ?? fallback} · Esc to interrupt`;
-  }
-  /** Screen replacement cannot leave components pointing at a stopped Pi host. */
-  rebind(screenChanged = true): void {
-    if (screenChanged) this.cancelDialogs(); this.unlisten?.();
-    this.unlisten = this.host.screen().addInputListener(data => { const filtered = this.filterInput(data); return filtered === undefined ? { consume: true } : { data: filtered }; });
-    for (const [key, slot] of [...this.widgets]) this.api.setWidget(key, slot.factory, { placement: slot.below ? "belowEditor" : "aboveEditor" });
-    if (this.headerSlot) this.api.setHeader(this.headerSlot.factory);
-    if (this.footerFactory) this.api.setFooter(this.footerFactory);
-    if (this.editorFactory) this.api.setEditorComponent(this.editorFactory);
-    this.branchChanged();
-  }
-  branchChanged(): void { for (const listener of this.branchListeners) this.attempt(listener); }
-  clearPartials(): void { for (const component of this.partialComponents.values()) component.dispose(); this.partialComponents.clear(); this.partials.clear(); }
-  cancelDialogs(): void { for (const cancel of [...this.pendingDialogs]) cancel(); }
-  private clear(): void {
-    this.generation++; this.cancelDialogs(); clearInterval(this.timer); this.timer = undefined;
-    if (this.hasTitle) { this.host.screen().terminal.setTitle("xeno"); this.hasTitle = false; }
-    this.unbind?.(); this.unbind = undefined; this.unwatchTools?.(); this.unwatchTools = undefined; this.clearPartials();
-    this.toolStates.clear();
-    this.reported.clear();
-    for (const slot of this.widgets.values()) slot.component.dispose(); this.widgets.clear(); this.mountWidgets();
-    this.headerSlot?.component.dispose(); this.headerSlot = undefined; this.header.clear();
-    this.footer?.dispose(); this.footer = undefined; this.footerFactory = undefined;
-    for (const unsubscribe of this.footerSubscriptions.splice(0)) unsubscribe();
-    this.editorFactory = undefined; this.attempt(() => this.host.editor.setComponent(undefined));
-    this.autocomplete = []; this.refreshCompletion(); this.statuses.clear(); this.listeners.clear(); this.branchListeners.clear();
-    this.workingMessage = undefined; this.workingVisible = true; this.frames = undefined; this.hiddenThinkingLabel = undefined;
-    this.themeCache = new Map(["dark", "light"].map(name => [name, { theme: this.theme(builtinTheme(name === "dark" ? "dark" : "light")), path: undefined }]));
-  }
-  dispose(): void { this.clear(); this.unlisten?.(); this.unlisten = undefined; }
-  transformMarkdown(text: string, width: number, streaming: boolean, messageType = "assistant"): string {
-    for (const transform of this.registry?.markdown ?? []) { const input = text; text = this.attempt(() => transform(input, { availableWidth: width, isStreaming: streaming, messageType })) ?? input; }
-    return text;
-  }
-  renderMessage(type: string, text: string, data: unknown, expanded: boolean, fallback: Component, metadata: { id: string; entry: boolean; timestamp: string }): Component {
-    const render = (metadata.entry ? this.registry?.entryRenderers : this.registry?.renderers)?.get(type);
-    const message = metadata.entry ? { type: "custom", id: metadata.id, timestamp: metadata.timestamp, customType: type, data }
-      : { role: "custom", customType: type, content: text, details: data, display: true, timestamp: Date.parse(metadata.timestamp) };
-    const component = render && this.attempt(() => render(message, { expanded, outputPad: this.host.outputPad() }, this.theme()));
-    return component ? this.own(component, fallback) : fallback;
-  }
-  renderTool(name: string, input: unknown, result: { text: string; ok: boolean; data?: unknown } | null, expanded: boolean, callFallback: Component, resultFallback: Component, id: string, partial?: ExtensionToolResult): OwnedComponent {
-    const tool = this.registry?.tools.get(name);
-    const context: ExtensionToolRenderContext = { args: input, toolCallId: id, invalidate: () => this.host.screen().requestRender(), lastComponent: undefined,
-      state: this.toolStates.get(id) ?? {}, cwd: this.host.cwd(), executionStarted: true, argsComplete: true, isPartial: !!partial, expanded, showImages: this.host.showImages(), isError: result?.ok === false };
-    const slots: { raw?: ExtensionComponent; owned?: OwnedComponent; failed?: boolean }[] = [{}, {}];
-    const slot = (index: number, factory: (() => ExtensionComponent) | undefined, fallback: Component): Component => {
-      const current = slots[index]!;
-      if (!factory || current.failed) return fallback;
-      context.lastComponent = current.raw;
-      try {
-        const raw = factory();
-        if (raw !== current.raw) { current.owned?.dispose(); current.raw = raw; current.owned = this.own(raw, fallback); }
-        return current.owned ?? fallback;
-      } catch (error) { current.failed = true; this.report(error); return fallback; }
-      finally { this.toolStates.set(id, context.state); }
-    };
-    const components = () => [slot(0, tool?.renderCall ? () => tool.renderCall!(input, this.theme(), context) : undefined, callFallback),
-      slot(1, result && tool?.renderResult ? () => tool.renderResult!(partial ?? {content:[{type:"text",text:result.text}], ...(result.data === undefined ? {} : { details: result.data as import("../core/tool-contract.ts").JsonValue }),isError:!result.ok}, {expanded,isPartial:!!partial},this.theme(),context) : undefined, resultFallback)];
-    return { render: width => components().flatMap(c => c.render(width)), invalidate: () => slots.forEach(slot => slot.owned?.invalidate()), dispose: () => slots.forEach(slot => slot.owned?.dispose()) };
-  }
-}

package/src/apps/resource-browser.ts

@@ -1,75 +0,0 @@
-/** Pi config selector behavior, using the same inventory as runtime loading. */
-import { SelectList } from "../tui/select.ts";
-import { createInteractiveTui } from "../tui/host.ts";
-import { installBindings, keyMatches } from "../tui/input.ts";
-import { getKeybindings } from "../vendor/pi-tui/keybindings.ts";
-import { truncateToWidth } from "../vendor/pi-tui/utils.ts";
-import { nextResourceOverride } from "../core/resource-selection.ts";
-import { discoverResources, setResourceOverride, type ResourceIndex, type ResourceOptions } from "../store/resource-index.ts";
-import { loadUiResources } from "../store/resources.ts";
-import { createStyle, IDENTITY, type Style } from "../tui/style.ts";
-import { colorEnabled } from "./render.ts";
-
-export class ResourceBrowser extends SelectList {
-  scope: "user" | "project" = "user";
-  index: ResourceIndex;
-  notice = "";
-  private readonly resourceOptions: ResourceOptions;
-  private readonly redraw: () => void;
-  private readonly changed: (() => Promise<void>) | undefined;
-  constructor(options: { resources: ResourceOptions; index: ResourceIndex; style: Style; redraw: () => void; changed?: () => Promise<void> }) {
-    super([], { title: "Resources", style: options.style, emptyMessage: "No resources found" });
-    this.resourceOptions = options.resources; this.index = options.index; this.redraw = options.redraw; this.changed = options.changed;
-    if(options.resources.local)this.scope="project";
-    this.refresh();
-  }
-  private refresh(): void {
-    this.setItems(this.index.entries.map(entry => ({ value: entry.kind + ":" + entry.path,
-      label: `[${entry.enabled ? "x" : " "}] ${entry.kind} · ${entry.name}${this.scope === "project" ? ` · ${entry.override}` : ""}`,
-      description: `${entry.scope}${entry.trusted ? "" : " · untrusted"}${entry.package?" · "+entry.package.source:""} · ${entry.path}` })));
-    this.redraw();
-  }
-  async handleAction(data: string): Promise<boolean> {
-    const kb = getKeybindings();
-    if (kb.matches(data, "tui.input.tab")) { this.scope = this.scope === "user" ? "project" : "user"; this.refresh(); return true; }
-    if (kb.matches(data, "tui.select.confirm")) return true;
-    if (!keyMatches(data, "space")) return false;
-    const selected = this.state.items[this.state.selected]?.value;
-    const entry = this.index.entries.find(row => row.kind + ":" + row.path === selected);
-    if (!entry) return true;
-    const state = this.scope === "project" ? nextResourceOverride(entry.override) : entry.inherited ? "skip" : "load";
-    try {
-      await setResourceOverride(this.index, entry, this.scope, state);
-      this.index = await discoverResources(this.resourceOptions);
-      await this.changed?.();
-      this.notice = entry.trusted ? "Saved and reloaded" : "Saved; project resources remain blocked until this project is trusted";
-    } catch (error) { this.notice = String(error); }
-    this.refresh(); return true;
-  }
-  override render(width: number): string[] {
-    return [`${this.scope === "user" ? "Global" : "Project"} Resources`, this.scope === "user" ? this.index.userDir : this.index.projectDir,
-      ...super.render(width).slice(1, -1), `${getKeybindings().getKeys("tui.input.tab").join("/")} scope · Space ${this.scope === "project" ? "inherit/+/-" : "toggle"} · ${getKeybindings().getKeys("tui.select.cancel").join("/")} close`, this.notice]
-      .filter(Boolean).map(line => truncateToWidth(line, width, ""));
-  }
-}
-
-/** Standalone configuration does not allocate a conversation or require a model credential. */
-export async function runResourceConfig(options: ResourceOptions, handoff?: () => void): Promise<void> {
-  const index = await discoverResources(options);
-  const ui = await loadUiResources(options, index);
-  const screen = createInteractiveTui();
-  const browser = new ResourceBrowser({ resources: options, index, style: colorEnabled() ? createStyle(ui.theme.colors) : IDENTITY, redraw: () => screen.requestRender() });
-  installBindings(ui.keymap.byAction);
-  screen.addChild(browser); screen.setFocus(browser);
-  try {
-    await new Promise<void>(resolve => {
-      let pending = Promise.resolve();
-      browser.onInput = data => { pending = pending.then(async () => {
-        if (await browser.handleAction(data)) return;
-        if (browser.acceptInput(data).cancelled) resolve();
-        screen.requestRender();
-      }).catch(error => { browser.notice = String(error); screen.requestRender(); }); };
-      handoff?.(); screen.start();
-    });
-  } finally { await screen.terminal.drainInput(); screen.stop(); }
-}

package/src/apps/session-browser.ts

@@ -1,113 +0,0 @@
-/** Pi selector interaction, backed exclusively by xeno's session store. Shared by startup and /resume. */
-import { SelectList, type SelectItem, type SelectState } from "../tui/select.ts";
-import { Input } from "../vendor/pi-tui/components/input.ts";
-import { fuzzyMatch } from "../vendor/pi-tui/fuzzy.ts";
-import { truncateToWidth } from "../vendor/pi-tui/utils.ts";
-import { keyMatches } from "../tui/input.ts";
-import { defaultKeymap, type Keymap } from "../core/keymap.ts";
-import { ACTION_ALIASES } from "../core/action-defaults.ts";
-import { parseSessionQuery, selectSessions, type SessionSort } from "../core/session-browser.ts";
-import { archiveSession, renameSession, scanSessionRoots, sessionRoots, type SessionRoot } from "../store/session-browser.ts";
-import type { ListedSession } from "../store/sessions.ts";
-import type { Style } from "../tui/style.ts";
-
-type Session = Extract<ListedSession, { ok: true }>;
-export class SessionBrowser extends SelectList {
-  private sessions: Session[] = [];
-  private readonly initial: SessionRoot;
-  private readonly redraw: () => void;
-  private readonly active: string | undefined;
-  private readonly bindings: () => Keymap;
-  private readonly renamed: ((path: string, name: string) => void) | undefined;
-  private scan = new AbortController();
-  private disposed = false;
-  private editing: { kind: "rename" | "archive"; session: Session; input: Input } | undefined;
-  scope: "current" | "all" = "current";
-  sort: SessionSort = "threaded";
-  named = false;
-  showPath = false;
-  progress = "";
-  notice = "";
-  constructor(options: { root: SessionRoot; style: Style; redraw: () => void; active?: string; bindings?: () => Keymap; renamed?: (path: string, name: string) => void }) {
-    super([], { style: options.style, title: "Resume session", emptyMessage: "No matching sessions", filter: (_items, query) => this.visible(query) });
-    this.initial = options.root; this.redraw = options.redraw; this.active = options.active; this.bindings = options.bindings ?? defaultKeymap;
-    this.renamed = options.renamed;
-  }
-  override get focused(): boolean { return this.editing?.input.focused ?? super.focused; }
-  override set focused(value: boolean) { super.focused = value; if (this.editing) this.editing.input.focused = value; }
-  get sessionCount(): number { return this.sessions.length; }
-  private visible(query: string): SelectItem[] {
-    return selectSessions(this.sessions, query, this.sort, this.named, fuzzyMatch).map(s => ({ value: s.path,
-      label: "  ".repeat(Math.min(12, s.depth)) + (s.depth ? "↳ " : "") + (s.name?.trim() || s.text?.split("\n").find(Boolean)?.slice(0, 100) || s.id),
-      description: this.showPath ? s.path : [s.updated_at ?? "", s.model ?? "", this.scope === "all" ? s.workspace ?? "" : ""].filter(Boolean).join(" · "),
-    }));
-  }
-  private refresh(): void { if (!this.disposed) { this.setItems([]); this.redraw(); } }
-  async load(): Promise<void> {
-    this.scan.abort(); const scan = this.scan = new AbortController();
-    this.sessions = []; this.progress = "Loading sessions…"; this.refresh();
-    try {
-      const roots = this.scope === "current" ? [this.initial] : await sessionRoots(this.initial);
-      for await (const batch of scanSessionRoots(roots, scan.signal)) {
-        if (this.disposed || scan !== this.scan) return;
-        this.sessions.push(...batch.sessions.filter((s): s is Session => s.ok));
-        for (const row of batch.sessions) if (!row.ok) this.notice = row.error;
-        this.progress = `Loading ${batch.loaded}/${batch.total}`; this.refresh();
-      }
-    } catch (error) { if (!scan.signal.aborted) this.notice = String(error); }
-    if (scan !== this.scan || this.disposed) return;
-    this.progress = ""; this.refresh();
-  }
-  dispose(): void { this.disposed = true; this.scan.abort(); }
-  private matches(data: string, action: string): boolean {
-    return (this.bindings().byAction[(ACTION_ALIASES[action] ?? action) as keyof Keymap["byAction"]] ?? []).some(chord => keyMatches(data, chord));
-  }
-  async handleAction(data: string): Promise<boolean> {
-    if (this.editing) {
-      if (this.matches(data, "tui.select.cancel") || keyMatches(data, "ctrl+c")) { this.editing = undefined; this.redraw(); return true; }
-      if (this.matches(data, "tui.select.confirm")) {
-        const edit = this.editing;
-        try {
-          if (edit.kind === "rename") {
-            await renameSession(edit.session.path, edit.input.getValue());
-            edit.session.name = edit.input.getValue().trim();
-            this.renamed?.(edit.session.path, edit.session.name);
-          } else {
-            const destination = await archiveSession(edit.session.path, this.active);
-            this.sessions = this.sessions.filter(s => s.path !== edit.session.path);
-            this.notice = `Kept at ${JSON.stringify(destination)}; restore the directory to ${JSON.stringify(edit.session.path)}`;
-          }
-          this.editing = undefined; this.refresh();
-        } catch (error) { this.notice = String(error); this.redraw(); }
-      } else if (this.editing.kind === "rename") this.editing.input.handleInput(data);
-      this.redraw(); return true;
-    }
-    if (this.matches(data, "tui.input.tab")) { this.scope = this.scope === "current" ? "all" : "current"; void this.load(); return true; }
-    if (this.matches(data, "app.session.toggleNamedFilter")) this.named = !this.named;
-    else if (this.matches(data, "app.session.toggleSort")) this.sort = this.sort === "threaded" ? "recent" : this.sort === "recent" ? "relevance" : "threaded";
-    else if (this.matches(data, "app.session.togglePath")) this.showPath = !this.showPath;
-    else if (["app.session.rename", "app.session.delete", "app.session.deleteNoninvasive"].some(action => this.matches(data, action))) {
-      const path = this.state.items[this.state.selected]?.value;
-      const session = this.sessions.find(s => s.path === path);
-      if (!session) return true;
-      const kind = this.matches(data, "app.session.rename") ? "rename" : "archive";
-      if (kind === "archive" && session.path === this.active) { this.notice = "Cannot remove the currently active session"; this.redraw(); return true; }
-      const input = new Input(); input.setValue(session.name ?? ""); input.focused = this.focused;
-      this.editing = { kind, session, input };
-    } else return false;
-    this.refresh(); return true;
-  }
-  override acceptInput(data: string): SelectState { const result = super.acceptInput(data); this.redraw(); return result; }
-  override render(width: number): string[] {
-    const header = this.progress === "Loading sessions…" ? this.progress : `Resume session · ${this.scope === "current" ? "Current folder" : "All workspaces"} · ${this.named ? "Named" : "All names"} · ${this.sort}`;
-    const hint = (action: string, label: string) => {
-      const keys = this.bindings().byAction[(ACTION_ALIASES[action] ?? action) as keyof Keymap["byAction"]];
-      return keys?.length ? `${keys.join("/")} ${label}` : "";
-    };
-    const body = this.editing ? [this.editing.kind === "rename" ? "Rename session" : "Remove session from this list? Original log will be kept in .trash.",
-      this.editing.session.name ?? this.editing.session.id, ...(this.editing.kind === "rename" ? this.editing.input.render(width) : []), "Enter confirm · Esc cancel"] :
-      [...super.render(width).slice(1, -1), [["tui.input.tab", "scope"], ["app.session.toggleNamedFilter", "named"], ["app.session.toggleSort", "sort"],
-        ["app.session.togglePath", "path"], ["app.session.rename", "rename"], ["app.session.delete", "remove"]].map(([action, label]) => hint(action!, label!)).filter(Boolean).join(" · "), 're:<pattern> regex · "phrase" exact'];
-    return [header, ...body, this.progress, parseSessionQuery(this.query).error ?? this.notice].filter(Boolean).map(line => truncateToWidth(line, width, ""));
-  }
-}

package/src/apps/session-picker.ts

@@ -1,55 +0,0 @@
-/** A startup picker owns only a terminal, never a provisional durable session. */
-import { sessionsDir, type ListedSession } from "../store/sessions.ts";
-import { registerSessionRoot, sessionRoots } from "../store/session-browser.ts";
-import { createInteractiveTui } from "../tui/host.ts";
-import type { SelectItem } from "../tui/select.ts";
-import { SessionBrowser } from "./session-browser.ts";
-import { installBindings } from "../tui/input.ts";
-import { defaultKeymap, type Keymap } from "../core/keymap.ts";
-import type { Style } from "../tui/style.ts";
-
-export function sessionItems(sessions: readonly ListedSession[]): SelectItem[] {
-  return sessions.flatMap((s) => s.ok ? [{
-    value: s.path,
-    label: s.name ?? s.id,
-    description: [s.model ?? "", s.updated_at ?? "", `${s.events} events`].filter(Boolean).join("  "),
-  }] : []);
-}
-
-export async function pickStartupSession(opts: {
-  workspace: string;
-  sessionDir?: string;
-  style: Style;
-  say: (line: string) => void;
-  keymap?: Keymap;
-}, handoff?: () => void): Promise<string | null> {
-  const root = { path: sessionsDir(opts.workspace, opts.sessionDir), workspace: opts.workspace };
-  await registerSessionRoot(root).catch(error => opts.say(String(error)));
-  const screen = createInteractiveTui();
-  const select = new SessionBrowser({ root, style: opts.style, redraw: () => screen.requestRender(), bindings: () => opts.keymap ?? defaultKeymap() });
-  installBindings((opts.keymap ?? defaultKeymap()).byAction);
-  screen.addChild(select);
-  screen.setFocus(select);
-  try {
-    return await new Promise<string | null>((resolve) => {
-      let pending = Promise.resolve();
-      select.onInput = (data) => { pending = pending.then(async () => {
-        if (await select.handleAction(data)) return;
-        const state = select.acceptInput(data);
-        if (state.cancelled) resolve(null);
-        else if (state.confirmed) resolve(state.confirmed.value);
-        else screen.requestRender();
-      }).catch(error => { opts.say(String(error)); }); };
-      handoff?.(); screen.start();
-      void select.load().then(async () => {
-        if (select.scope === "current" && !select.sessionCount && !select.notice && (await sessionRoots(root)).length === 1) {
-          opts.say("No sessions to resume"); resolve(null);
-        }
-      }).catch(error => { opts.say(String(error)); });
-    });
-  } finally {
-    select.dispose();
-    await screen.terminal.drainInput();
-    screen.stop();
-  }
-}

package/src/tui/ansi.ts

@@ -1,67 +0,0 @@
-/**
- * Escape sequences the renderer emits. Each constant names the standard it
- * comes from and what breaks without it -- a bare number in a CSI is otherwise
- * a magic that nobody can audit.
- */
-
-/**
- * DECSET 2026 — begin synchronized output.
- * Spec: https://gist.github.com/christianparpart/d8d62cc110656ba92d4e171cec8a547a
- * (mode 2026, adopted by xterm, tmux, kitty, iTerm2, Windows Terminal).
- * Without this, tmux paints each cursor move as its own frame and the user
- * sees the cursor jump and the frame tear while a diff is applied.
- */
-export const SYNC_BEGIN = "\x1b[?2026h";
-
-/**
- * DECRST 2026 — end synchronized output, the matching close of SYNC_BEGIN.
- * Omitting it leaves the terminal buffering subsequent output forever, so
- * the next frame (and everything after) never appears.
- */
-export const SYNC_END = "\x1b[?2026l";
-
-/**
- * CR — carriage return. ASCII 0x0D / ECMA-48. Returns to column 0 of the
- * current row so a changed line can be overwritten in place.
- */
-export const CR = "\r";
-
-/**
- * LF — line feed. ASCII 0x0A / ECMA-48. Advances onto a newly grown row of
- * the live region; a CSI CUD at the bottom of the screen is clamped and
- * would overwrite the last line instead of extending the region.
- */
-export const LF = "\n";
-
-/**
- * CSI CUU — cursor up N rows. ECMA-48 §8.3.14. Relative moves are what make
- * a line-diff possible without knowing the absolute row of the live region
- * (a main-screen TUI does not own the viewport origin).
- */
-export function cursorUp(n: number): string {
-  return n > 0 ? `\x1b[${n}A` : "";
-}
-
-/**
- * CSI CUD — cursor down N rows. ECMA-48 §8.3.13. Used to skip unchanged
- * lines when the cursor sits above them, not to grow the region (see LF).
- */
-export function cursorDown(n: number): string {
-  return n > 0 ? `\x1b[${n}B` : "";
-}
-
-/**
- * CSI EL 0 — erase from cursor to end of line. ECMA-48 §8.3.41.
- * Without it a shorter replacement leaves the tail of the previous longer
- * line sitting on screen.
- */
-export const ERASE_LINE_TAIL = "\x1b[K";
-
-/**
- * CSI ED 0 — erase from cursor to end of display. ECMA-48 §8.3.39.
- * Used when the new frame is shorter than the old one. Safe only because
- * the live region sits at the bottom of the main screen: anything below it
- * is leftover rows of a taller previous frame, not the user's scrollback
- * (scrollback is above us).
- */
-export const ERASE_DOWN = "\x1b[J";