pi-ui-extension 1.1.0

package/extensions/mcp/resources.ts

@@ -0,0 +1,31 @@
+export type McpResourceEntry = {
+  readonly name: string;
+  readonly description: string;
+};
+
+type McpStatusServer = {
+  readonly name?: unknown;
+  readonly disabled?: unknown;
+};
+
+/** Convert the adapter's read-only status snapshot into configured, enabled MCP rows. */
+export function mcpResourceEntriesFromStatus(value: unknown): readonly McpResourceEntry[] {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return [];
+  const snapshot = value as { version?: unknown; servers?: unknown };
+  if (snapshot.version !== 1 || !Array.isArray(snapshot.servers)) return [];
+
+  const seen = new Set<string>();
+  const rows: McpResourceEntry[] = [];
+  for (const rawServer of snapshot.servers) {
+    if (typeof rawServer !== "object" || rawServer === null || Array.isArray(rawServer)) continue;
+    const server = rawServer as McpStatusServer;
+    const name = typeof server.name === "string" ? server.name.trim() : "";
+    if (!name || server.disabled === true || seen.has(name)) continue;
+    seen.add(name);
+    rows.push({
+      name,
+      description: "MCP server loaded in the current Pi session",
+    });
+  }
+  return rows;
+}

package/extensions/resource-dialog.test.ts

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { loadResourceEntries, resourceDialogOptions, type ResourceEntry } from "./index.ts";
+
+test("resource categories avoid unrelated package discovery and reuse loaded context content", async (t) => {
+ const { SettingsManager, DefaultPackageManager } = await import("@earendil-works/pi-coding-agent");
+ const { mkdtemp, writeFile, rm } = await import("node:fs/promises");
+ const { tmpdir } = await import("node:os");
+ const { join } = await import("node:path");
+ t.mock.method(SettingsManager, "create", () => { throw new Error("unexpected settings read"); });
+ t.mock.method(DefaultPackageManager.prototype, "resolve", async () => { throw new Error("unexpected package scan"); });
+ const mcp = [{name:"demo",description:"MCP server"}];
+ assert.strictEqual(await loadResourceEntries({} as any, "/nonexistent", mcp, false, "mcp"), mcp);
+ const pi = {getCommands:()=>[{source:"skill",name:"skill:review",description:" Review  code "},{source:"extension",name:"other"}]} as any;
+ assert.deepEqual(await loadResourceEntries(pi, "/nonexistent", [], false, "skills"), [{name:"review",description:"Review code"}]);
+ const directory = await mkdtemp(join(tmpdir(), "resource-context-"));
+ try {
+  const content = "# Project\n\nLocal context description\n";
+  await writeFile(join(directory, "AGENTS.md"), content);
+  const rows = await loadResourceEntries({} as any, directory, [], false, "agents");
+  assert.ok(rows.some(row => row.content === content && row.description === "Local context description"));
+ } finally { await rm(directory, {recursive:true, force:true}); }
+});
+
+test("resource dialog keeps every resource row for selector scrolling", () => {
+  const rows: ResourceEntry[] = Array.from({ length: 13 }, (_, index) => ({
+    name: `skill-${index + 1}`,
+    description: `Description ${index + 1}`,
+  }));
+
+  const options = resourceDialogOptions(rows);
+
+  assert.equal(options.length, rows.length);
+  assert.equal(options[0], "skill-1 — Description 1");
+  assert.equal(options[12], "skill-13 — Description 13");
+});
+
+test("resource dialog keeps the existing one-line description limit", () => {
+  const options = resourceDialogOptions([{
+    name: "skill",
+    description: "x".repeat(200),
+  }]);
+
+  assert.equal(options[0], `skill — ${"x".repeat(109)}…`);
+});

package/extensions/session/mutations.test.ts

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { deleteSessionFile } from "./mutations.ts";
+
+test("trash failures never permanently delete the session", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "session-trash-"));
+  const path = join(directory, "session.jsonl");
+  try {
+    await writeFile(path, "session data\n");
+    for (const failure of [new Error("spawn trash ENOENT"), new Error("timed out"), { code: 1, stderr: "permission denied\n" }, { code: 2, stderr: "" }]) {
+      const pi = { async exec() { if (failure instanceof Error) throw failure; return failure; } } as any;
+      const result = await deleteSessionFile(pi, path);
+      assert.equal(result.ok, false);
+      if (!result.ok) assert.ok(result.error.length > 0);
+      assert.equal(await readFile(path, "utf8"), "session data\n");
+    }
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("successful trash execution passes the session path to trash", async () => {
+  const calls: unknown[][] = [];
+  const pi = { async exec(...args: unknown[]) { calls.push(args); return { code: 0, stderr: "" }; } } as any;
+  assert.deepEqual(await deleteSessionFile(pi, "/tmp/session.jsonl"), { ok: true, method: "trash" });
+  assert.deepEqual(calls, [["trash", ["/tmp/session.jsonl"], { timeout: 10_000 }]]);
+});

package/extensions/session/mutations.ts

@@ -0,0 +1,17 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export type DeleteSessionResult =
+  | { readonly ok: true; readonly method: "trash" }
+  | { readonly ok: false; readonly error: string };
+
+/** Only use recoverable deletion. A trash failure must never trigger permanent deletion. */
+export async function deleteSessionFile(pi: ExtensionAPI, path: string): Promise<DeleteSessionResult> {
+  try {
+    const result = await pi.exec("trash", [path], { timeout: 10_000 });
+    if (result.code === 0) return { ok: true, method: "trash" };
+    const hint = result.stderr.trim().split(/\r?\n/, 1)[0];
+    return { ok: false, error: hint || `trash exited with code ${result.code}` };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}

package/extensions/session/panel.test.ts

@@ -0,0 +1,238 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { TuiInputListener } from "@earendil-works/pi-tui";
+import { SessionPanel, type SessionListItem } from "./panel.ts";
+
+const theme = { fg: (_color: string, text: string) => text } as any;
+
+function session(id: string, title: string): SessionListItem {
+  return {
+    id,
+    title,
+    modified: new Date(0),
+    messageCount: 1,
+    current: false,
+  };
+}
+
+async function flushAsync(): Promise<void> {
+  await new Promise<void>((resolve) => setImmediate(resolve));
+}
+
+test("clicking the Sessions title refreshes the saved session list", async () => {
+  let listener: TuiInputListener | undefined;
+  let loads = 0;
+  const snapshots = [
+    [session("old", "Old session")],
+    [session("new", "New session")],
+  ];
+  const tui = {
+    addInputListener(next: TuiInputListener) {
+      listener = next;
+      return () => {};
+    },
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui,
+    getDesiredWidth: () => 40,
+    loadSessions: async () => snapshots[Math.min(loads++, snapshots.length - 1)]!,
+    onSelect() {},
+    onRename() {},
+    onOpenResources() {},
+    onDelete() {},
+    onDeleteOthers() {},
+    now: () => 0,
+  });
+  tui.currentLayout = {
+    root: {
+      component: panel,
+      rect: { x: 10, y: 5, width: 40, height: 7 },
+      clip: { x: 10, y: 5, width: 40, height: 7 },
+      children: [],
+    },
+  };
+
+  panel.refresh();
+  await flushAsync();
+  assert.match(panel.render(40).join("\n"), /Old session/);
+  assert.match(panel.render(40)[0]!, /SESSIONS ↻/);
+
+  assert.deepEqual(listener?.("\u001b[<0;20;6M"), { consume: true });
+  assert.deepEqual(listener?.("\u001b[<0;20;6m"), { consume: true });
+  await flushAsync();
+
+  assert.equal(loads, 2);
+  const output = panel.render(40).join("\n");
+  assert.match(output, /New session/);
+  assert.doesNotMatch(output, /Old session/);
+  panel.dispose();
+});
+
+test("renders and opens the MCP resource button", async () => {
+  let listener: TuiInputListener | undefined;
+  let opened: string | undefined;
+  const tui = {
+    addInputListener(next: TuiInputListener) {
+      listener = next;
+      return () => {};
+    },
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui,
+    getDesiredWidth: () => 40,
+    loadSessions: async () => [session("one", "One session")],
+    onSelect() {},
+    onRename() {},
+    onDelete() {},
+    onDeleteOthers() {},
+    onOpenResources(button) { opened = button; },
+    now: () => 0,
+  });
+  tui.currentLayout = {
+    root: {
+      component: panel,
+      rect: { x: 10, y: 5, width: 40, height: 5 },
+      clip: { x: 10, y: 5, width: 40, height: 5 },
+      children: [],
+    },
+  };
+
+  panel.refresh();
+  await flushAsync();
+  assert.match(panel.render(40).join("\n"), /MCP/);
+
+  assert.deepEqual(listener?.("\u001b[<0;43;9M"), { consume: true });
+  assert.deepEqual(listener?.("\u001b[<0;43;9m"), { consume: true });
+  await flushAsync();
+
+  assert.equal(opened, "mcp");
+  panel.dispose();
+});
+
+test("releasing outside the Sessions title cancels a refresh click", async () => {
+  let listener: TuiInputListener | undefined;
+  let loads = 0;
+  const tui = {
+    addInputListener(next: TuiInputListener) {
+      listener = next;
+      return () => {};
+    },
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui,
+    getDesiredWidth: () => 40,
+    loadSessions: async () => {
+      loads++;
+      return [];
+    },
+    onSelect() {},
+    onRename() {},
+    onDelete() {},
+    onDeleteOthers() {},
+    onOpenResources() {},
+  });
+  tui.currentLayout = {
+    root: {
+      component: panel,
+      rect: { x: 10, y: 5, width: 40, height: 7 },
+      clip: { x: 10, y: 5, width: 40, height: 7 },
+      children: [],
+    },
+  };
+
+  panel.refresh();
+  await flushAsync();
+  listener?.("\u001b[<0;20;6M");
+  listener?.("\u001b[<0;20;7m");
+  await flushAsync();
+
+  assert.equal(loads, 1);
+  panel.dispose();
+});
+
+test("renders ⊗ and clears every other session without refreshing", async () => {
+  let listener: TuiInputListener | undefined;
+  let loads = 0;
+  let cleared = 0;
+  const tui = {
+    addInputListener(next: TuiInputListener) {
+      listener = next;
+      return () => {};
+    },
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui,
+    getDesiredWidth: () => 40,
+    loadSessions: async () => {
+      loads++;
+      return [session("one", "One session")];
+    },
+    onSelect() {},
+    onRename() {},
+    onDelete() {},
+    onDeleteOthers() { cleared++; },
+    onOpenResources() {},
+    now: () => 0,
+  });
+  tui.currentLayout = {
+    root: {
+      component: panel,
+      rect: { x: 10, y: 5, width: 40, height: 7 },
+      clip: { x: 10, y: 5, width: 40, height: 7 },
+      children: [],
+    },
+  };
+
+  panel.refresh();
+  await flushAsync();
+  assert.match(panel.render(40)[0]!, /⊗/);
+
+  // ⊗ sits at the right edge of the title row: content column 33 of 38.
+  assert.deepEqual(listener?.("\u001b[<0;46;6M"), { consume: true });
+  assert.deepEqual(listener?.("\u001b[<0;46;6m"), { consume: true });
+  await flushAsync();
+
+  assert.equal(cleared, 1);
+  assert.equal(loads, 1);
+  panel.dispose();
+});
+
+test("hides ⊗ on narrow panels", async () => {
+  const tui = {
+    addInputListener: () => () => {},
+    requestRender() {},
+    currentLayout: undefined as any,
+  } as any;
+  const panel = new SessionPanel(theme, {
+    tui,
+    getDesiredWidth: () => 16,
+    loadSessions: async () => [],
+    onSelect() {},
+    onRename() {},
+    onDelete() {},
+    onDeleteOthers() {},
+    onOpenResources() {},
+    now: () => 0,
+  });
+  tui.currentLayout = {
+    root: {
+      component: panel,
+      rect: { x: 0, y: 0, width: 16, height: 7 },
+      clip: { x: 0, y: 0, width: 16, height: 7 },
+      children: [],
+    },
+  };
+
+  panel.refresh();
+  await flushAsync();
+  assert.doesNotMatch(panel.render(16)[0]!, /⊗/);
+  panel.dispose();
+});