@visual-z/xeno 0.1.4 → 0.2.0

package/src/apps/project-trust.ts

@@ -0,0 +1,49 @@
+import { dirname } from "node:path";
+import { SelectList } from "../tui/select.ts";
+import { createInteractiveTui } from "../tui/host.ts";
+import { IDENTITY } from "../tui/style.ts";
+import { installBindings } from "../tui/input.ts";
+import { loadUiResources } from "../store/resources.ts";
+import type { Style } from "../tui/style.ts";
+import { projectTrust, saveTrust } from "../store/trust.ts";
+import { truncateToWidth } from "../vendor/pi-tui/utils.ts";
+
+export type TrustChoice = "once" | "here" | "parent" | "never";
+export async function applyTrustChoice(workspace: string, choice: TrustChoice): Promise<boolean> {
+  if (choice !== "once") await saveTrust(choice === "parent" ? dirname(workspace) : workspace, choice !== "never");
+  return choice !== "never";
+}
+export class TrustSelector extends SelectList {
+  private readonly workspace: string;
+  private readonly decision: Awaited<ReturnType<typeof projectTrust>>;
+  constructor(workspace: string, decision: Awaited<ReturnType<typeof projectTrust>>, style: Style) {
+    super([
+      { value: "once", label: "Trust for this session", description: "Load project resources without saving a decision" },
+      { value: "here", label: "Trust this directory", description: workspace },
+      { value: "parent", label: "Trust parent directory", description: dirname(workspace) },
+      { value: "never", label: "Do not trust this directory", description: "Skip project configuration and executable extensions" },
+    ], { title: "Project trust", search: false, style,
+      ...(decision.saved ? { selectedValue: decision.saved.trusted ? decision.saved.path === workspace ? "here" : "parent" : "never" } : {}) });
+    this.workspace = workspace; this.decision = decision;
+  }
+  override render(width: number): string[] {
+    const saved = this.decision.saved;
+    return ["Project trust", this.workspace, `Saved: ${saved ? `${saved.trusted ? "trusted" : "untrusted"} (${saved.path})` : "none"}`,
+      `Current session: ${this.decision.trusted ? "trusted" : "untrusted"} · Tool permissions are separate`, ...super.render(width).slice(1)]
+      .map(line => truncateToWidth(line, width, ""));
+  }
+}
+export async function pickProjectTrust(workspace: string): Promise<boolean> {
+  const decision = await projectTrust(workspace);
+  installBindings((await loadUiResources({ workspace, trusted: false })).keymap.byAction);
+  const screen = createInteractiveTui();
+  const select = new TrustSelector(workspace, decision, IDENTITY);
+  screen.addChild(select); screen.setFocus(select);
+  try {
+    const choice = await new Promise<string | null>(resolve => {
+      select.onInput = data => { const state = select.acceptInput(data); if (state.cancelled) resolve(null); else if (state.confirmed) resolve(state.confirmed.value); screen.requestRender(); };
+      screen.start();
+    });
+    return choice === null ? false : applyTrustChoice(workspace, choice as TrustChoice);
+  } finally { await screen.terminal.drainInput(); screen.stop(); }
+}

package/src/apps/render.ts

@@ -200,6 +200,7 @@ export function formatEvent(
     case "text_delta":
     case "thinking_delta":
     case "discard":
+    case "progress":
       return [];
     default:
       return assertNever(e.kind, "formatEvent");

package/src/apps/resource-browser.ts

@@ -0,0 +1,75 @@
+/** 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): 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(); }); };
+      screen.start();
+    });
+  } finally { await screen.terminal.drainInput(); screen.stop(); }
+}

package/src/apps/resources.ts

@@ -0,0 +1,25 @@
+import { loadSessionResources, visibleSchemas, type App } from "./startup.ts";
+import { loadCatalog } from "../runtime/catalog.ts";
+import { readModelSources } from "../store/models.ts";
+import { publishModelCatalog } from "./model-catalog.ts";
+
+/** Stage local resources, persist their checkpoint, then publish their UI/runtime views together. */
+export async function reloadAppResources(app: App): Promise<boolean> {
+  const resources = await loadSessionResources(app.args, app.workspace, app.io, app.projectTrusted);
+  const catalog = loadCatalog(await readModelSources());
+  for (const warning of catalog.warnings) app.io.say(app.io.palette.yellow(warning));
+  const cut = await app.session.reloadResources({ system: resources.system, tools: visibleSchemas(app.args, resources.extensions) });
+  const modelCut = await publishModelCatalog(app, catalog.models, cut);
+  await app.extensions?.dispose();
+  app.extensions = resources.extensions;
+  app.session.config.tools.extensions = resources.extensions.definitions();
+  app.session.config.tools.extensionHooks = resources.extensions.toolHooks();
+  app.loadedContext = resources.loadedContext;
+  app.slash = resources.slash;
+  app.ui = resources.ui;
+  app.ui.settings = { ...app.ui.settings, thinking: app.providerConfig.effort };
+  app.resources = resources.index;
+  app.projectTrusted = resources.trusted;
+  app.system = app.session.config.frozen.system;
+  return cut || modelCut;
+}

package/src/apps/session-browser.ts

@@ -0,0 +1,113 @@
+/** 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

@@ -0,0 +1,55 @@
+/** 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;
+}): 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)); }); };
+      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();
+  }
+}