pi-umbra 0.1.0

package/node_modules/pi-umbra-inputbar/README.md

@@ -0,0 +1,19 @@
+# pi-umbra-inputbar
+
+pi's input bar, rebuilt: a chevron prompt, the session name on the border, a colour you pick, and a command to rename the session.
+
+```
+pi-umbra-inputbar/
+├── checks
+│   └── umbra-inputbar.check.ts
+└── extensions
+    └── umbra-inputbar.ts
+```
+
+## Install
+
+```sh
+pi install npm:pi-umbra-inputbar
+```
+
+MIT.

package/node_modules/pi-umbra-inputbar/checks/umbra-inputbar.check.ts

@@ -0,0 +1,53 @@
+// inputbar.ts: the title splice, the colour resolver, and the editor itself - pi's real
+// CustomEditor under stub tui/theme/keybindings - to prove the name lands on the top border
+// and the /umb-color override outlives pi's own borderColor assignments.
+//
+// Run it with:  bun run umbra-inputbar.check.ts
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import inputbar, { InputBar, NAMED, paintWith, resolvePaint, withTitle } from "../extensions/umbra-inputbar.ts";
+
+assert.equal(withTitle("─".repeat(20), undefined), "─".repeat(20), "no name, no change");
+const titled = withTitle("─".repeat(20), "π - repo");
+assert.equal(visibleWidth(titled), 20, "same width after the splice");
+assert.ok(titled.endsWith(" π - repo ──"), "label at the right, two dashes after it");
+assert.equal(withTitle("─".repeat(8), "π - a long name"), "─".repeat(8), "no room: untouched");
+const wrapped = withTitle(`\x1b[34m${"─".repeat(30)}\x1b[39m`, "x");
+assert.ok(wrapped.startsWith("\x1b[34m") && wrapped.endsWith(" x ──\x1b[39m"), "label lands inside the colour wrap");
+assert.ok(withTitle("── ✻ working ─────────────────", "s").startsWith("── ✻ working "), "the left-side spinner is left alone");
+// The label carries the footer's colour, so its reset has to be followed by the border's own.
+const painted = withTitle("─".repeat(20), "n", (t) => `[${t}]`, (t) => `{${t}}`);
+assert.ok(painted.endsWith("[ n ]{──}"), "label painted, and the two dashes after it repainted");
+assert.equal(visibleWidth(withTitle("─".repeat(20), "n")), 20, "unpainted by default, so width is unchanged");
+
+assert.equal(resolvePaint("off"), undefined, "off restores the theme");
+assert.equal(resolvePaint("orange")!("ab"), "\x1b[38;2;255;137;4mab\x1b[39m", "a palette name paints its fixed truecolor");
+assert.equal(resolvePaint("#ff8800")!("ab"), "\x1b[38;2;255;136;0mab\x1b[39m", "a raw hex still works");
+assert.deepEqual(Object.keys(NAMED), ["red", "orange", "yellow", "green", "cyan", "blue", "purple", "pink"], "the eight names");
+assert.throws(() => resolvePaint("nope"), /unknown colour "nope" - one of: off, red/, "an unknown name lists the palette");
+
+// The editor. The stub pi only has to answer getSessionName; on/registerCommand are recorded.
+const commands: Record<string, object> = {};
+inputbar({ on() {}, registerCommand: (name: string, def: object) => (commands[name] = def), getSessionName: () => "π - t" } as never);
+assert.ok(commands["umb-color"], "registers /umb-color");
+const bar = new InputBar({ requestRender() {} } as never, { borderColor: (s: string) => `<${s}>`, selectList: {} } as never, {} as never);
+const render = bar as unknown as { renderTopBorder(w: number, h: number): string; renderBottomBorder(w: number, h: number): string };
+// borderColor is the stub `<...>`: the label sits unpainted (no ui yet), the two dashes after it
+// carry a wrap of their own, and pi's own wrap still closes the line.
+assert.ok(render.renderTopBorder(24, 0).endsWith(" π - t <──>>"), "session name on the top border, tail repainted");
+assert.equal(visibleWidth(render.renderTopBorder(24, 0).replace(/[<>]/g, "")), 24, "top border keeps its width");
+
+bar.borderColor = (s) => `[${s}]`; // what pi does on a thinking-level change
+assert.equal(render.renderBottomBorder(4, 0), "[────]", "pi's assignment is honoured while no override is set");
+paintWith("orange");
+assert.equal(render.renderBottomBorder(4, 0), "\x1b[38;2;255;137;4m────\x1b[39m", "/umb-color paints the border");
+bar.borderColor = (s) => `(${s})`; // pi assigns again...
+assert.equal(render.renderBottomBorder(4, 0), "\x1b[38;2;255;137;4m────\x1b[39m", "...and the override still wins");
+paintWith("off");
+assert.equal(render.renderBottomBorder(4, 0), "(────)", "off hands the border back to pi's last colour");
+
+
+console.log("umbra-inputbar.check.ts ok - title splice 8 cases, paint 5 cases, editor: name on border, override beats 2 reassignments");

package/node_modules/pi-umbra-inputbar/extensions/umbra-inputbar.ts

@@ -0,0 +1,130 @@
+// The input bar: the session name on its top border (right side) and /umb-color for its border
+// colour. Both ride on pi's own extension point - ctx.ui.setEditorComponent with a subclass of
+// CustomEditor - so no bundle patch is involved. The name is read from pi.getSessionName() at
+// every render, so /umb-rename shows on the next repaint; /umb-color persists in
+// ~/.pi/agent/input-color.
+import { CustomEditor, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const COLOR_FILE = join(homedir(), ".pi", "agent", "input-color");
+const HEX = /^#[0-9a-f]{6}$/i;
+// The palette /umb-color offers: the Tailwind 400 family, which reads on every dark theme.
+export const NAMED: Record<string, string> = {
+	red: "#ff6467",
+	orange: "#ff8904",
+	yellow: "#ffb900",
+	green: "#00d492",
+	cyan: "#00d3f2",
+	blue: "#51a2ff",
+	purple: "#a78bfa",
+	pink: "#fb64b6",
+};
+const NAMES = ["off", ...Object.keys(NAMED)];
+
+type Paint = (s: string) => string;
+// The factory type lives on the ui context, not on the package root.
+type EditorFactory = NonNullable<Parameters<ExtensionContext["ui"]["setEditorComponent"]>[0]>;
+let paint: Paint | undefined; // the /umb-color override; undefined = the theme's border colour
+let sessionName: () => string | undefined = () => undefined;
+let ui: ExtensionContext["ui"] | undefined;
+
+// Neither the terminal background nor the spinner frames are handled here. umbra-background owns
+// the first and umbra-working the second. Both were written from two files at once for a while,
+// and in each case the last writer won at random.
+
+// Right-aligns the label inside the last run of "─" on an already rendered border line, leaving
+// the working spinner pi embeds on the left alone. Too little room: the line is returned unchanged.
+//
+// The label is painted rather than left to inherit the border, so the session name reads in the
+// same colour as the "Working" text at the other end of the row. Its colour reset would hand the
+// rest of the line back to the terminal default, so the two dashes after it are repainted.
+export const withTitle = (
+	line: string,
+	label: string | undefined,
+	paintLabel: Paint = (s) => s,
+	paintTail: Paint = (s) => s,
+): string => {
+	if (!label) return line;
+	const text = ` ${label} `;
+	const w = visibleWidth(text);
+	return line.replace(/─{2,}(?!.*─)/s, (run) =>
+		run.length >= w + 4 ? "─".repeat(run.length - w - 2) + paintLabel(text) + paintTail("──") : run,
+	);
+};
+
+// A palette name (or a raw "#rrggbb") paints truecolor; "off" restores the theme's border.
+export const resolvePaint = (spec: string): Paint | undefined => {
+	if (spec === "off") return undefined;
+	const hex = NAMED[spec] ?? (HEX.test(spec) ? spec : undefined);
+	if (!hex) throw new Error(`unknown colour "${spec}" - one of: ${NAMES.join(", ")}`);
+	const on = `\x1b[38;2;${[1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16)).join(";")}m`;
+	return (s) => `${on}${s}\x1b[39m`;
+};
+export const paintWith = (spec: string): Paint | undefined => (paint = resolvePaint(spec));
+
+export class InputBar extends CustomEditor {
+	constructor(...args: ConstructorParameters<typeof CustomEditor>) {
+		// `prompt` is an editor option, so the chevron needs no patch. pi's default is "> ".
+		super(args[0], args[1], args[2], { prompt: "❯ ", ...args[3], embedWorkingStatus: true });
+		// pi assigns borderColor again on bash mode and thinking-level changes; the override has to
+		// win every time, so the field becomes an accessor over whatever pi last assigned.
+		let stored = this.borderColor;
+		Object.defineProperty(this, "borderColor", {
+			get: () => paint ?? stored,
+			set: (fn: Paint) => {
+				stored = fn;
+			},
+			configurable: true,
+			enumerable: true,
+		});
+	}
+	protected override renderTopBorder(width: number, hiddenLineCount: number): string {
+		return withTitle(
+			super.renderTopBorder(width, hiddenLineCount),
+			sessionName(),
+			(text) => ui?.theme.fg("muted", text) ?? text,
+			(text) => this.borderColor(text),
+		);
+	}
+}
+
+const factory: EditorFactory = (tui, theme, keybindings) => new InputBar(tui, theme, keybindings);
+
+export default function (pi: ExtensionAPI) {
+	sessionName = () => pi.getSessionName();
+	pi.on("session_start", (_event, ctx) => {
+		ui = ctx.ui;
+		ctx.ui.setEditorComponent(factory);
+		if (!existsSync(COLOR_FILE)) return;
+		try {
+			paintWith(readFileSync(COLOR_FILE, "utf8").trim());
+		} catch {
+			paint = undefined;
+		}
+	});
+	pi.registerCommand("umb-color", {
+		description: "input bar colour: /umb-color red | orange | yellow | green | cyan | blue | purple | pink | off",
+		getArgumentCompletions(text) {
+			const items = NAMES.filter((n) => n.startsWith(text.trim())).map((n) => ({ value: n, label: n }));
+			return items.length ? items : null;
+		},
+		async handler(args, ctx) {
+			const spec = args.trim();
+			if (!spec) {
+				const now = existsSync(COLOR_FILE) ? readFileSync(COLOR_FILE, "utf8").trim() : "theme border";
+				return ctx.ui.notify(`input bar: ${now}  -  /umb-color ${NAMES.join(" | ")}`);
+			}
+			try {
+				paintWith(spec);
+			} catch (error) {
+				return ctx.ui.notify((error as Error).message, "error");
+			}
+			if (paint) writeFileSync(COLOR_FILE, `${spec}\n`);
+			else if (existsSync(COLOR_FILE)) unlinkSync(COLOR_FILE);
+			ctx.ui.notify(`input bar: ${spec}`);
+		},
+	});
+}

package/node_modules/pi-umbra-inputbar/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "pi-umbra-inputbar",
+  "version": "0.1.0",
+  "description": "pi's input bar, rebuilt: a chevron prompt, the session name on the border, a colour you pick, and a command to rename the session.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "tui",
+    "editor",
+    "prompt"
+  ],
+  "author": "grkn",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grknbyk/pi-umbra.git",
+    "directory": "pi-umbra-inputbar"
+  },
+  "homepage": "https://github.com/grknbyk/pi-umbra/tree/main/pi-umbra-inputbar#readme",
+  "bugs": "https://github.com/grknbyk/pi-umbra/issues",
+  "files": [
+    "extensions",
+    "checks",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  }
+}

package/node_modules/pi-umbra-preview/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 grkn
+
+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/node_modules/pi-umbra-preview/README.md

@@ -0,0 +1,32 @@
+# pi-umbra-preview
+
+Render a document with pandoc and open it in the browser, from inside pi.
+
+```
+pi-umbra-preview/
+├── checks
+│   └── umbra-preview.check.ts
+└── extensions
+    └── umbra-preview.ts
+```
+
+## Needs pandoc
+
+Not bundled, never installed for you. It is looked for when a preview is asked for, not at
+load, so a missing pandoc costs one message rather than a failed extension.
+
+| | |
+|---|---|
+| Windows | `winget install --id JohnMacFarlane.Pandoc -e` |
+| macOS | `brew install pandoc` |
+| Linux | `sudo apt install pandoc` |
+
+A PDF or an HTML file opens directly and needs no pandoc.
+
+## Install
+
+```sh
+pi install npm:pi-umbra-preview
+```
+
+MIT.

package/node_modules/pi-umbra-preview/checks/umbra-preview.check.ts

@@ -0,0 +1,38 @@
+// The two things in preview.ts that can be wrong without anything failing: the path a user typed
+// is resolved to the wrong file, and pandoc is reported missing on a machine that has it.
+//
+//   bun run umbra-preview.check.ts
+import assert from "node:assert";
+import { join, resolve } from "node:path";
+import { findPandoc, resolvePath } from "../extensions/umbra-preview.ts";
+
+const cwd = process.platform === "win32" ? "C:\\work" : "/work";
+
+// pi writes `@path` when a file is picked from its own completion, and a shell leaves quotes on a
+// path with a space in it. Both reach the handler as typed.
+assert.equal(resolvePath("notes.md", cwd), resolve(cwd, "notes.md"), "a relative path joins cwd");
+assert.equal(resolvePath("@notes.md", cwd), resolve(cwd, "notes.md"), "the @ prefix is pi's, not the filename's");
+assert.equal(resolvePath('  "a b.md"  ', cwd), resolve(cwd, "a b.md"), "quotes and padding come off");
+assert.equal(resolvePath(join(cwd, "x.md"), cwd), join(cwd, "x.md"), "an absolute path is left alone");
+
+// PATH wins, and nothing else is looked at when it answers.
+const onPath = await findPandoc(
+    () => {
+        throw new Error("the fallback list must not be read when PATH answers");
+    },
+    async () => true,
+);
+assert.equal(onPath, "pandoc", "a pandoc on PATH is used as a bare command");
+
+// The reason the fallback list exists: pandoc's own installer puts it somewhere the running shell
+// does not know about yet, so the first preview after installing must still work.
+const installed = "C:\\Users\\x\\AppData\\Local\\Pandoc\\pandoc.exe";
+const found = await findPandoc((path) => path.endsWith("pandoc.exe") || path === "/usr/bin/pandoc", async () => false);
+assert.ok(found !== undefined, "a pandoc off PATH must still be found");
+assert.ok(found !== "pandoc", "an off-PATH pandoc is used by its full path, not by name");
+
+// Nowhere on this machine: the caller has to be told, not handed a command that will not start.
+assert.equal(await findPandoc(() => false, async () => false), undefined, "no pandoc means no pandoc");
+
+void installed;
+console.log("umbra-preview: all checks passed");

package/node_modules/pi-umbra-preview/extensions/umbra-preview.ts

@@ -0,0 +1,147 @@
+// Reading a Markdown file in a terminal means reading its source. This renders it instead: pandoc
+// turns the document into one self-contained HTML file and the system browser opens it.
+//
+// pandoc is not bundled and is never installed for you. It is looked for when a preview is asked
+// for, not at load, so a missing pandoc costs one message rather than a failed extension. The
+// message names the install command for the platform it is printed on.
+//
+// A PDF or an HTML file is opened directly. pandoc reads neither, and converting a PDF to HTML to
+// look at a PDF is work with nothing at the end of it.
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, platform, tmpdir } from "node:os";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+/** Formats the browser opens as they are. Converting these would lose more than it gained. */
+const DIRECT = new Set([".pdf", ".html", ".htm", ".svg", ".png", ".jpg", ".jpeg", ".gif", ".webp"]);
+
+/** Everything pandoc is asked to read. An unlisted extension is still tried, and pandoc says no. */
+const MARKDOWN = new Set([".md", ".markdown", ".mdx"]);
+
+// Where pandoc lands when its own installer runs and the shell has not been restarted, so the
+// first preview after `winget install` works instead of reporting a missing program that is there.
+const FALLBACK_PATHS: Record<string, string[]> = {
+    win32: [
+        join(homedir(), "AppData", "Local", "Pandoc", "pandoc.exe"),
+        "C:\\Program Files\\Pandoc\\pandoc.exe",
+    ],
+    darwin: ["/usr/local/bin/pandoc", "/opt/homebrew/bin/pandoc"],
+    linux: ["/usr/bin/pandoc", "/usr/local/bin/pandoc"],
+};
+
+const INSTALL: Record<string, string> = {
+    win32: "winget install --id JohnMacFarlane.Pandoc -e",
+    darwin: "brew install pandoc",
+    linux: "sudo apt install pandoc",
+};
+
+// Mermaid is a diagram language pandoc has no renderer for: it passes the block through as code.
+// Loading mermaid's own script in the produced page is what draws it, and the block only carries
+// its weight when the document actually has a diagram in it.
+const MERMAID_HEADER = `<script type="module">
+import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs";
+for (const block of document.querySelectorAll("pre.mermaid > code, code.language-mermaid")) {
+    const host = document.createElement("pre");
+    host.className = "mermaid";
+    host.textContent = block.textContent;
+    (block.closest("pre") ?? block).replaceWith(host);
+}
+mermaid.initialize({ startOnLoad: true });
+</script>
+`;
+
+const run = (command: string, args: string[]): Promise<{ code: number; stderr: string }> =>
+    new Promise((done) => {
+        const child = spawn(command, args, { windowsHide: true });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => (stderr += String(chunk)));
+        child.on("error", () => done({ code: -1, stderr: "could not start " + command }));
+        child.on("close", (code) => done({ code: code ?? -1, stderr }));
+    });
+
+/** The pandoc this machine has, or undefined. PATH first, then where the installer puts it. */
+export const findPandoc = async (
+    exists: (path: string) => boolean = existsSync,
+    probe: (command: string) => Promise<boolean> = async (command) =>
+        (await run(command, ["--version"])).code === 0,
+): Promise<string | undefined> => {
+    if (await probe("pandoc")) return "pandoc";
+    return (FALLBACK_PATHS[platform()] ?? []).find(exists);
+};
+
+/** Opening a file is one command per platform and none of them take the same arguments. */
+const openInBrowser = (path: string): void => {
+    const [command, args] =
+        platform() === "win32"
+            ? ["cmd", ["/c", "start", "", path]]
+            : platform() === "darwin"
+              ? ["open", [path]]
+              : ["xdg-open", [path]];
+    spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
+};
+
+/** The path a user typed, which may be relative, quoted, or prefixed with pi's own `@`. */
+export const resolvePath = (argument: string, cwd: string): string => {
+    const bare = argument.trim().replace(/^@/, "").replace(/^["']|["']$/g, "");
+    return isAbsolute(bare) ? bare : resolve(cwd, bare);
+};
+
+export default function preview(pi: ExtensionAPI) {
+    const out = join(tmpdir(), "pi-umbra-preview");
+
+    const show = async (argument: string, ctx: ExtensionCommandContext): Promise<void> => {
+        if (argument.trim() === "") {
+            ctx.ui.notify("Which file? /umb-preview <path>", "warning");
+            return;
+        }
+        const source = resolvePath(argument, process.cwd());
+        if (!existsSync(source)) {
+            ctx.ui.notify(`No such file: ${source}`, "error");
+            return;
+        }
+
+        const extension = extname(source).toLowerCase();
+        if (DIRECT.has(extension)) {
+            openInBrowser(source);
+            ctx.ui.notify(`Opened ${basename(source)}.`, "info");
+            return;
+        }
+
+        const pandoc = await findPandoc();
+        if (pandoc === undefined) {
+            ctx.ui.notify(
+                `pandoc is needed to render ${extension || "this file"} and was not found. Install it with:  ${INSTALL[platform()] ?? "your package manager"}`,
+                "warning",
+            );
+            return;
+        }
+
+        mkdirSync(out, { recursive: true });
+        const target = join(out, `${basename(source, extension)}.html`);
+        // --standalone gives a whole page rather than a fragment, --embed-resources inlines the
+        // images so the file in the temp directory still shows them, and math is rendered by the
+        // browser. `--mathml` is the spelling pandoc deprecated; this one is the current name.
+        const args = [source, "-o", target, "--standalone", "--embed-resources", "--math-method=mathml"];
+
+        // Only markdown gets the mermaid loader, and only when a diagram is actually in the file.
+        if (MARKDOWN.has(extension) && readFileSync(source, "utf8").includes("```mermaid")) {
+            const header = join(out, "mermaid.html");
+            writeFileSync(header, MERMAID_HEADER);
+            args.push("--include-in-header", header);
+        }
+
+        const { code, stderr } = await run(pandoc, args);
+        if (code !== 0) {
+            ctx.ui.notify(`pandoc failed: ${stderr.split("\n")[0] ?? `exit ${code}`}`, "error");
+            return;
+        }
+        openInBrowser(target);
+        ctx.ui.notify(`Rendered ${basename(source)} and opened it.`, "info");
+    };
+
+    pi.registerCommand("umb-preview", {
+        description: "Render a document with pandoc and open it in the browser: /umb-preview <path>",
+        handler: show,
+    });
+}

package/node_modules/pi-umbra-preview/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "pi-umbra-preview",
+  "version": "0.1.0",
+  "description": "Render a document with pandoc and open it in the browser, from inside pi.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "pandoc",
+    "preview",
+    "markdown"
+  ],
+  "author": "grkn",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grknbyk/pi-umbra.git",
+    "directory": "pi-umbra-preview"
+  },
+  "homepage": "https://github.com/grknbyk/pi-umbra/tree/main/pi-umbra-preview#readme",
+  "bugs": "https://github.com/grknbyk/pi-umbra/issues",
+  "files": [
+    "extensions",
+    "checks",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  }
+}

package/node_modules/pi-umbra-rename/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 grkn
+
+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/node_modules/pi-umbra-rename/README.md

@@ -0,0 +1,19 @@
+# pi-umbra-rename
+
+One command that renames a pi session and the terminal window title together, which pi keeps behind two separate APIs.
+
+```
+pi-umbra-rename/
+├── checks
+│   └── umbra-rename.check.ts
+└── extensions
+    └── umbra-rename.ts
+```
+
+## Install
+
+```sh
+pi install npm:pi-umbra-rename
+```
+
+MIT.

package/node_modules/pi-umbra-rename/checks/umbra-rename.check.ts

@@ -0,0 +1,55 @@
+// /umb-rename writes two names through two different APIs, and the terminal title is built from
+// a third value. A fake pi is enough to pin all three, because the command is the whole extension.
+//
+//   bun run umbra-rename.check.ts
+import assert from "node:assert";
+import rename from "../extensions/umbra-rename.ts";
+
+type Handler = (args: string, ctx: unknown) => Promise<void>;
+
+const load = (sessionName?: string) => {
+	const calls = { name: undefined as string | undefined, title: undefined as string | undefined, notice: "" };
+	let handler: Handler | undefined;
+	const pi = {
+		registerCommand: (_name: string, options: { handler: Handler }) => void (handler = options.handler),
+		getSessionName: () => sessionName,
+		setSessionName: (value: string) => void (calls.name = value),
+	};
+	rename(pi as never);
+	const ctx = {
+		ui: {
+			setTitle: (value: string) => void (calls.title = value),
+			notify: (value: string) => void (calls.notice = value),
+			input: async () => prompted,
+		},
+		sessionManager: { getCwd: () => "/home/me/projects/real-estate" },
+	};
+	return { calls, run: (args: string) => handler!(args, ctx) };
+};
+
+let prompted: string | undefined;
+
+// The argument form. The prefix goes on the terminal title only: pi already spells the session
+// name on the input bar, so a π in the name itself would show up three times in two places.
+const given = load();
+await given.run("  ledger  ");
+assert.equal(given.calls.name, "ledger", "the name is trimmed and carries no prefix");
+assert.equal(given.calls.title, "π - ledger - real-estate", "the title carries the prefix and the cwd");
+assert.equal(given.calls.notice, "renamed: ledger");
+
+// No argument: pi asks, and the current name is the prefill.
+prompted = "ledger";
+const asked = load("old-name");
+await asked.run("");
+assert.equal(asked.calls.name, "ledger", "the answer to the prompt is the new name");
+
+// Nothing typed, or the prompt dismissed, must leave both names alone rather than blanking them.
+for (const answer of [undefined, "", "   "]) {
+	prompted = answer;
+	const cancelled = load("old-name");
+	await cancelled.run("");
+	assert.equal(cancelled.calls.name, undefined, `"${answer}" must not rename`);
+	assert.equal(cancelled.calls.title, undefined, `"${answer}" must not retitle`);
+}
+
+console.log("umbra-rename.check.ts ok - argument form, prompt form, 3 cancel cases");

package/node_modules/pi-umbra-rename/extensions/umbra-rename.ts

@@ -0,0 +1,22 @@
+import { basename } from "node:path";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+// /umb-rename sets both names at once: the session display name (session selector,
+// /resume) and the terminal window/tab title, which are separate APIs in pi.
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("umb-rename", {
+		description: "Rename this session and the terminal title: /umb-rename <name>",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			// setSessionName lives on the API object; setTitle lives on the command context's UI.
+			let newName = args.trim() || (await ctx.ui.input("Rename session", pi.getSessionName() ?? ""))?.trim();
+			if (!newName) return;
+
+			// The prefix belongs to the terminal title only. pi builds that title itself as
+			// `π - <session name> - <cwd>`, so putting π in the session name too spelled it twice
+			// in the tab and once more on the input bar, which shows the session name alone.
+			pi.setSessionName(newName);
+			ctx.ui.setTitle(`π - ${newName} - ${basename(ctx.sessionManager.getCwd())}`);
+			ctx.ui.notify(`renamed: ${newName}`);
+		},
+	});
+}