@tiagojct/subsub 0.20.0 → 0.21.0

package/dist/subsub.js

@@ -13,9 +13,9 @@
  * The Python servers start in session_start (not in the factory) and stop in
  * session_shutdown. Tools are registered once and use the current bridge.
  */
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Bridge } from "./bridge.js";
 import { expand, findUv, FREE_MODELS, loadConfig, parseEnvFile, serverCommand, starbuckCommand, starbuckEnabled, uiLanguage, who, } from "./config.js";
@@ -28,7 +28,13 @@ import { applyEdits, checkLiteratureNote, field, frontMatter, itemKeyOf, missing
 import { buildPolicy, isSecret, judgePath, normalizeToolPath, realish, within } from "./paths.js";
 import { describeArgs, formatPreview, isEmptyPreview } from "./preview.js";
 import { perMinuteWait, providerTrouble, TROUBLE_TEXT, TROUBLE_TEXT_PT } from "./keys.js";
-import { headerLines, paintPreview, QUOTES, schemeFromAnsi, themeName } from "./look.js";
+import { headerLines, LIBRARIAN_THEME, paintPreview, QUOTES, schemeFromAnsi, themeName } from "./look.js";
+import { footerLines, toolRenderers, usageTotals } from "./chrome.js";
+import { ApprovalView } from "./dialogs.js";
+import { allowedFile, listNotes, OPENABLE, openFile } from "./files.js";
+import { LibraryView, NotesView } from "./screens.js";
+import { glyphs, paintFromTheme, workingFrames } from "./skin.js";
+import { loadWords, toolWord } from "./words.js";
 import { systemAddition } from "./prompt.js";
 import { logUsage } from "./usage.js";
 import { gateKind, SERVER_PREFIXES, toolsFor, unavailableReason, outboundProblem } from "./roles.js";
@@ -124,6 +130,14 @@ export async function createSubsub(pi, deps = {}) {
     let scheme;
     let modelId = "no model";
     let headerTui;
+    let footerTui;
+    /** True once the session started with the look on; the tool renderers are asked before a context exists. */
+    let lookActive = false;
+    let words;
+    const redraw = () => {
+        headerTui?.requestRender();
+        footerTui?.requestRender();
+    };
     const library = { zotero: "checking" };
     const quote = cfg.quotes === false ? undefined : QUOTES[Math.floor(Math.random() * QUOTES.length)];
     const lookOn = (ctx) => standalone && cfg.look !== false && ctx.mode === "tui";
@@ -163,15 +177,110 @@ export async function createSubsub(pi, deps = {}) {
         if (!lookOn(ctx) || cfg.themes === false)
             return;
         scheme ??= schemeFromAnsi(ctx.ui.theme.getFgAnsi("text"), ctx.ui.theme.name);
-        const name = themeName(scheme, cfg.themes || undefined);
+        // The Librarian has its own plate (madder); a theme named in the settings applies to both modes unless themes.librarian says otherwise.
+        const base = mode === "librarian" ? (cfg.themesLibrarian ?? cfg.themes ?? LIBRARIAN_THEME) : cfg.themes || undefined;
+        const name = themeName(scheme, base, ctx.ui.theme.getColorMode?.());
         const theme = name ? ctx.ui.getTheme(name) : undefined;
         // A Theme object (not a name) changes the theme for this run only; the saved setting stays.
         if (theme)
             ctx.ui.setTheme(theme);
+        // The working indicator takes the accent of the mode.
+        const mark = paintFromTheme(ctx.ui.theme).mark;
+        ctx.ui.setWorkingIndicator?.({ frames: workingFrames(glyphs(), Boolean(process.env.SUBSUB_REDUCE_MOTION && process.env.SUBSUB_REDUCE_MOTION !== "0")).map(mark), intervalMs: 160 });
+    }
+    /**
+     * Ask the user to approve a change. With the look on, the preview opens as an overlay with its own keys (see dialogs.ts); otherwise, and over RPC,
+     * it is pi's confirm dialog. Only a yes counts: anything else, including an overlay that cannot open, is a no.
+     */
+    async function approve(ctx, title, body) {
+        if (lookOn(ctx) && typeof ctx.ui.custom === "function") {
+            const answer = await ctx.ui.custom((tui, theme, _keys, done) => new ApprovalView({ title, body, lang, paint: paintFromTheme(theme), glyphs: glyphs(), done, rows: () => tui.terminal?.rows ?? 24, redraw: () => tui.requestRender() }), { overlay: true, overlayOptions: { width: "92%", minWidth: 40, maxHeight: "92%", anchor: "center", margin: 1 } });
+            return answer === true;
+        }
+        return (await ctx.ui.confirm(title, body)) === true;
+    }
+    /** The notes and library screens cover the terminal: the conversation is behind them and comes back when they close. */
+    const OVERLAY = { overlay: true, overlayOptions: { width: "100%", maxHeight: "100%", anchor: "top-left", margin: 0 } };
+    /** True when the terminal look can show a screen of its own; otherwise says where the same thing is. */
+    function screenOk(ctx) {
+        if (lookOn(ctx) && typeof ctx.ui.custom === "function")
+            return true;
+        ctx.ui.notify(L("Sub-Sub: this screen is part of the terminal look. In subsub web, use the Notes button and the library search.", "Sub-Sub: este ecrã faz parte do aspeto do terminal. Em subsub web, use o botão Notas e a pesquisa na biblioteca."), "info");
+        return false;
+    }
+    /** /notes: the notes in the Sub-Sub folder, newest first; the note under the cursor shows beside the list. */
+    async function openNotes(ctx) {
+        if (!screenOk(ctx))
+            return;
+        const root = cfg.vault ?? ctx.cwd;
+        const notes = listNotes(root);
+        const { Markdown } = await import("@earendil-works/pi-tui");
+        const { getMarkdownTheme } = await import("@earendil-works/pi-coding-agent");
+        await ctx.ui.custom((tui, theme, _keys, done) => new NotesView({
+            notes,
+            read: (path) => {
+                const file = allowedFile(path, root, cfg.vault);
+                return file && statSync(file).size < 2_000_000 ? readFileSync(file, "utf8") : "";
+            },
+            markdown: (text, width) => new Markdown(text, 1, 0, getMarkdownTheme()).render(width),
+            open: (path) => {
+                const file = allowedFile(path, root, cfg.vault);
+                if (file && OPENABLE.has(extname(file).toLowerCase()))
+                    openFile(file, cfg.vault);
+            },
+            done: () => done(),
+            lang,
+            paint: paintFromTheme(theme),
+            glyphs: glyphs(),
+            rows: () => tui.terminal?.rows ?? 24,
+            redraw: () => tui.requestRender(),
+        }), OVERLAY);
+    }
+    /** /library: search as you type; Enter puts /read <item> in the box (the Librarian gets the key), ctrl+n puts /lit-note <item>. */
+    async function openLibrary(ctx) {
+        if (!screenOk(ctx))
+            return;
+        const ref = (it) => it.citekey || it.key;
+        await ctx.ui.custom((tui, theme, _keys, done) => new LibraryView({
+            search: async (query) => {
+                const r = await current().call("zotero_find_items", { query, limit: 25 });
+                if (r.isError)
+                    throw new Error(r.text);
+                return (r.data?.items ?? []).filter((it) => it && it.key);
+            },
+            choose: (it) => {
+                ctx.ui.setEditorText(mode === "researcher" ? `/read ${ref(it)}` : ref(it));
+                done();
+            },
+            note: (it) => {
+                ctx.ui.setEditorText(`/lit-note ${ref(it)}`);
+                done();
+            },
+            done: () => done(),
+            lang,
+            paint: paintFromTheme(theme),
+            glyphs: glyphs(),
+            researcher: mode === "researcher",
+            rows: () => tui.terminal?.rows ?? 24,
+            redraw: () => tui.requestRender(),
+        }), OVERLAY);
+    }
+    /** /actions: the buttons of the web view as a list; the choice goes into the box, so the user adds what is missing and presses Enter. */
+    async function openActions(ctx) {
+        const w = words ?? (await loadWords());
+        const list = [...(mode === "researcher" ? w.ACTIONS.research : []), ...w.ACTIONS.library].filter((a) => a.needs !== "starbuck" || starbuckEnabled(cfg));
+        const labels = list.map((a) => `${a[lang]}   /${a.cmd}`);
+        const pick = await ctx.ui.select(L("Actions", "Ações"), labels);
+        const a = list[labels.indexOf(pick ?? "")];
+        if (a)
+            ctx.ui.setEditorText(a.cmd.endsWith(" ") ? `/${a.cmd}` : `/${a.cmd} `);
     }
     function paintFor(ctx) {
         return (text) => ctx.mode === "tui"
-            ? paintPreview(text, (x) => ctx.ui.theme.fg("success", x), (x) => ctx.ui.theme.fg("error", x), (x) => ctx.ui.theme.fg("text", x))
+            ? (() => {
+                const p = paintFromTheme(ctx.ui.theme);
+                return paintPreview(text, p.ok, p.strike, p.text);
+            })()
             : text;
     }
     async function refreshLibrary() {
@@ -190,7 +299,7 @@ export async function createSubsub(pi, deps = {}) {
         catch {
             library.zotero = "down";
         }
-        headerTui?.requestRender();
+        redraw();
         emitWeb();
     }
     function setHeader(ctx) {
@@ -209,26 +318,45 @@ export async function createSubsub(pi, deps = {}) {
                         library,
                         quote,
                         width,
-                        paint: {
-                            mark: (x) => th.fg("accent", x),
-                            text: (x) => th.fg("text", x),
-                            muted: (x) => th.fg("muted", x),
-                            dim: (x) => th.fg("dim", x),
-                            warn: (x) => th.fg("warning", x),
-                        },
+                        paint: paintFromTheme(th),
+                        lang,
+                        glyphs: glyphs(),
                     });
                 },
                 invalidate() { },
             };
         });
     }
+    function setFooter(ctx) {
+        if (!lookOn(ctx))
+            return;
+        ctx.ui.setFooter((tui) => {
+            footerTui = tui;
+            return {
+                render: (width) => {
+                    try {
+                        const usage = ctx.getContextUsage();
+                        const totals = usageTotals(ctx.sessionManager.getEntries());
+                        return footerLines({ mode, lang, library, model: modelId, percent: usage?.percent ?? null, window: usage?.contextWindow, tokens: totals.tokens, cost: totals.cost, down: bridge ? Object.keys(bridge.errors) : [] }, width, paintFromTheme(ctx.ui.theme), glyphs());
+                    }
+                    catch {
+                        return []; // the context is gone after shutdown
+                    }
+                },
+                invalidate() { },
+                dispose() {
+                    footerTui = undefined;
+                },
+            };
+        });
+    }
     function status(ctx) {
         modelId = ctx.model ? `${ctx.model.id}` : "no model";
         const down = bridge ? Object.keys(bridge.errors) : ["zotero", "scholar"];
         ctx.ui.setStatus("subsub", `Sub-Sub: ${mode} | ${modelId}${down.length ? ` | not running: ${down.join(", ")}` : ""}`);
         if (standalone)
             ctx.ui.setTitle(`Sub-Sub: ${mode}`);
-        headerTui?.requestRender();
+        redraw();
         webCtx = ctx;
         emitWeb();
     }
@@ -252,6 +380,7 @@ export async function createSubsub(pi, deps = {}) {
         }
         if (remember)
             pi.appendEntry(MODE_ENTRY, { mode });
+        applyTheme(ctx);
         status(ctx);
     }
     pi.on("session_start", async (_event, ctx) => {
@@ -279,11 +408,14 @@ export async function createSubsub(pi, deps = {}) {
         // Judge light or dark before Sub-Sub changes the theme.
         if (lookOn(ctx))
             scheme ??= schemeFromAnsi(ctx.ui.theme.getFgAnsi("text"), ctx.ui.theme.name);
-        applyTheme(ctx);
+        lookActive = lookOn(ctx);
+        if (lookActive)
+            words = await loadWords().catch(() => undefined);
         await applyMode(ctx, restored ?? (pi.getFlag("librarian") ? "librarian" : pi.getFlag("researcher") ? "researcher" : cfg.defaultMode), false, !modelChosen);
         logUsage(cfg.usageLog, { ev: "session", mode, model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined });
         if (lookOn(ctx)) {
             setHeader(ctx);
+            setFooter(ctx);
             void refreshLibrary();
         }
         else if (webView) {
@@ -319,6 +451,18 @@ export async function createSubsub(pi, deps = {}) {
             await applyMode(ctx, m, false, false);
     });
     pi.on("model_select", async (_event, ctx) => status(ctx));
+    // Plain-word tool lines for Sub-Sub's own tools (the look only); pi's tools keep pi's rows.
+    const rows = toolRenderers({ word: (name) => (words ? toolWord(words, lang, name) : name), lang, glyphs, paint: paintFromTheme });
+    pi.registerToolRenderer?.((toolName, next) => (lookActive && SERVER_PREFIXES.some((p) => toolName.startsWith(p)) ? rows(toolName) : next()));
+    pi.on("tool_execution_start", async (event, ctx) => {
+        if (lookActive && words && !event.parentToolCallId)
+            ctx.ui.setWorkingMessage?.(`${toolWord(words, lang, event.toolName)}...`);
+    });
+    pi.on("tool_execution_end", async (_event, ctx) => {
+        if (lookActive)
+            ctx.ui.setWorkingMessage?.();
+    });
+    pi.on("turn_end", async () => redraw());
     // A provider error in plain words (quota, busy, blocked, key); the web view words its own.
     pi.on("message_end", async (event, ctx) => {
         const m = event.message;
@@ -433,7 +577,7 @@ export async function createSubsub(pi, deps = {}) {
                 return undefined;
             if (!ctx.hasUI)
                 return { block: true, reason: `Writing ${target} needs ${user}'s approval: ${verdict.why}.` };
-            const ok = await ctx.ui.confirm(`Sub-Sub: ${name} ${target}?`, L(`Asking because ${verdict.why}.`, `Pergunto porque: ${verdict.why}.`));
+            const ok = await approve(ctx, `Sub-Sub: ${name} ${target}?`, L(`Asking because ${verdict.why}.`, `Pergunto porque: ${verdict.why}.`));
             return ok ? undefined : { block: true, reason: `${user} did not allow writing to that file.` };
         }
         if (!ctx.hasUI) {
@@ -446,7 +590,7 @@ export async function createSubsub(pi, deps = {}) {
                 if (!verdict.ok && /protected|hidden/.test(verdict.why))
                     return { block: true, reason: `Sub-Sub does not write there: ${verdict.why}.` };
             }
-            const ok = await ctx.ui.confirm(L(`Sub-Sub: run ${name}?`, `Sub-Sub: executar ${name}?`), describeArgs(input));
+            const ok = await approve(ctx, L(`Sub-Sub: run ${name}?`, `Sub-Sub: executar ${name}?`), describeArgs(input));
             return ok ? undefined : { block: true, reason: `${user} did not approve. Ask what to change.` };
         }
         // kind === "preview": the server computes the change first, then the user decides.
@@ -472,7 +616,7 @@ export async function createSubsub(pi, deps = {}) {
         // The dialog may stay open for minutes. Before applying, compute the preview again: if the
         // library changed meanwhile (an edit in Zotero, new items), show the new preview instead.
         for (let round = 0; round < 3; round++) {
-            const ok = await ctx.ui.confirm(round ? `${title} ${L("(the library changed; this is the new preview)", "(a biblioteca mudou; esta é a nova pré-visualização)")}` : title, paintFor(ctx)(shown));
+            const ok = await approve(ctx, round ? `${title} ${L("(the library changed; this is the new preview)", "(a biblioteca mudou; esta é a nova pré-visualização)")}` : title, paintFor(ctx)(shown));
             logUsage(cfg.usageLog, { ev: "change", tool: name, approved: ok });
             if (!ok)
                 return { block: true, reason: `${user} did not approve this change. Ask what to change; do not retry the same call.` };
@@ -586,7 +730,7 @@ export async function createSubsub(pi, deps = {}) {
         }
         if (!ctx.hasUI)
             return { block: true, reason: `Writing a Starbuck report to ${dir} needs ${user}'s approval: ${verdict.why}.` };
-        const ok = await ctx.ui.confirm(L(`Sub-Sub: write the Starbuck report to ${dir}?`, `Sub-Sub: escrever o relatório do Starbuck em ${dir}?`), L(`Asking because ${verdict.why}.`, `Pergunto porque: ${verdict.why}.`));
+        const ok = await approve(ctx, L(`Sub-Sub: write the Starbuck report to ${dir}?`, `Sub-Sub: escrever o relatório do Starbuck em ${dir}?`), L(`Asking because ${verdict.why}.`, `Pergunto porque: ${verdict.why}.`));
         return ok ? undefined : { block: true, reason: `${user} did not allow writing the report there. Ask where to put it (report_dir).` };
     }
     async function benchGate(name, input, kind, cwd, signal) {
@@ -621,20 +765,30 @@ export async function createSubsub(pi, deps = {}) {
                 `for ${user}.${shown}`,
         };
     }
+    const switchTo = async (ctx, next) => {
+        await applyMode(ctx, next, true);
+        ctx.ui.notify(next === "librarian"
+            ? L("Sub-Sub: Librarian mode. For searches and notes, switch to /researcher.", "Sub-Sub: modo Bibliotecário. Para pesquisas e notas, mude para /researcher.")
+            : L("Sub-Sub: Researcher mode. It searches, writes notes and also changes the library, with a preview.", "Sub-Sub: modo Investigador. Pesquisa, escreve notas e também altera a biblioteca, com pré-visualização."), "info");
+    };
     pi.registerCommand("librarian", {
         description: "Sub-Sub: switch to the Librarian (manages the library: tags, imports, metadata, PDFs)",
-        handler: async (_args, ctx) => {
-            await applyMode(ctx, "librarian", true);
-            ctx.ui.notify(L("Sub-Sub: Librarian mode. For searches and notes, switch to /researcher.", "Sub-Sub: modo Bibliotecário. Para pesquisas e notas, mude para /researcher."), "info");
-        },
+        handler: async (_args, ctx) => switchTo(ctx, "librarian"),
     });
     pi.registerCommand("researcher", {
         description: "Sub-Sub: switch to the Researcher (searches, notes, reviews, and everything the Librarian does)",
-        handler: async (_args, ctx) => {
-            await applyMode(ctx, "researcher", true);
-            ctx.ui.notify(L("Sub-Sub: Researcher mode. It searches, writes notes and also changes the library, with a preview.", "Sub-Sub: modo Investigador. Pesquisa, escreve notas e também altera a biblioteca, com pré-visualização."), "info");
-        },
+        handler: async (_args, ctx) => switchTo(ctx, "researcher"),
     });
+    // Screens of the terminal look (the web view has its own panels, so these are only for the `subsub` command).
+    if (standalone) {
+        pi.registerCommand("notes", { description: "Sub-Sub: the notes in your Sub-Sub folder", handler: async (_args, ctx) => openNotes(ctx) });
+        pi.registerCommand("library", { description: "Sub-Sub: search your Zotero library as you type", handler: async (_args, ctx) => openLibrary(ctx) });
+        pi.registerCommand("actions", { description: "Sub-Sub: the actions of the web view, as a list", handler: async (_args, ctx) => openActions(ctx) });
+        pi.registerShortcut?.("alt+n", { description: "Sub-Sub: notes", handler: (ctx) => openNotes(ctx) });
+        pi.registerShortcut?.("alt+l", { description: "Sub-Sub: library search", handler: (ctx) => openLibrary(ctx) });
+        pi.registerShortcut?.("alt+a", { description: "Sub-Sub: actions", handler: (ctx) => openActions(ctx) });
+        pi.registerShortcut?.("alt+m", { description: "Sub-Sub: switch between the Researcher and the Librarian", handler: (ctx) => switchTo(ctx, mode === "researcher" ? "librarian" : "researcher") });
+    }
     pi.registerCommand("subsub", {
         description: "Sub-Sub: Zotero connection and library overview",
         handler: async (_args, ctx) => {
@@ -660,7 +814,7 @@ export async function createSubsub(pi, deps = {}) {
                         : `Items: ${o.items}. Without tags: ${o.without_manual_tags}. Missing facets: ${JSON.stringify(o.missing_facet)}. Awaiting review (_agent): ${o.awaiting_review}.`);
                 }
             }
-            headerTui?.requestRender();
+            redraw();
             emitWeb();
             ctx.ui.notify(lines.join("\n"), "info");
         },
@@ -713,6 +867,12 @@ export async function createSubsub(pi, deps = {}) {
     // A registered command runs before the input hook, so /read checks the mode itself.
     pi.registerCommand("read", {
         description: "Sub-Sub: read a paper with guidance; Sub-Sub finds the passages and asks, you write the answers. /read [background|fact|extract|critique] <citekey, DOI, PMID or title words>",
+        getArgumentCompletions: (prefix) => {
+            if (/\s/.test(prefix.trim()))
+                return null;
+            const found = Object.keys(PURPOSES).filter((k) => k.startsWith(prefix.trim().toLowerCase()));
+            return found.length ? found.map((k) => ({ value: k, label: L(PURPOSES[k][0], PURPOSES[k][1]) })) : null;
+        },
         handler: async (args, ctx) => {
             if (mode === "librarian")
                 return ctx.ui.notify(researcherOnly("read"), "warning");
@@ -840,7 +1000,7 @@ export async function createSubsub(pi, deps = {}) {
                 ctx.ui.notify(preview.text, "warning");
                 return;
             }
-            const ok = await ctx.ui.confirm(L("Sub-Sub: undo?", "Sub-Sub: anular?"), paintFor(ctx)(formatPreview("zotero_undo", preview.data, lang)));
+            const ok = await approve(ctx, L("Sub-Sub: undo?", "Sub-Sub: anular?"), paintFor(ctx)(formatPreview("zotero_undo", preview.data, lang)));
             if (!ok)
                 return;
             const res = await current().call("zotero_undo", { ...input, dry_run: false });

package/dist/web.js

@@ -15,18 +15,16 @@
  */
 import { spawn } from "node:child_process";
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { createReadStream, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync, appendFileSync } from "node:fs";
+import { createReadStream, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync, appendFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { homedir } from "node:os";
-import { basename, dirname, extname, join, normalize, relative, resolve, sep } from "node:path";
+import { basename, dirname, extname, join, normalize, relative, sep } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { agentDirFor, chooseCwd, PACKAGE_DIR, packageVersion } from "./cli.js";
-import { configPath, expand, loadConfig, RECOMMENDED_MODELS, readConfigFile, saveConfig, uiLanguage, withStarbuck } from "./config.js";
+import { configPath, loadConfig, RECOMMENDED_MODELS, readConfigFile, saveConfig, uiLanguage, withStarbuck } from "./config.js";
 import { TESTED_MODELS } from "./init.js";
 import { KEY_PROVIDERS, saveApiKey } from "./keys.js";
-import { NOTE_DIRS, obsidianRoot, SETTINGS_DIR } from "./layout.js";
 import { field, frontMatter } from "./notes.js";
-import { realish, within } from "./paths.js";
 export function parseWebArgs(args) {
     const o = { port: 0, open: true, librarian: false, here: false, idleMinutes: 10, piArgs: [] };
     for (let i = 0; i < args.length; i++) {
@@ -51,6 +49,9 @@ export function parseWebArgs(args) {
 export { uiLanguage } from "./config.js";
 // ---------------------------------------------------------------- providers (API keys)
 export { KEY_PROVIDERS, saveApiKey } from "./keys.js";
+// ---------------------------------------------------------------- files (shared with the terminal screens)
+import { allowedFile, listNotes, openExternal, openFile, OPENABLE, wikilinkTarget } from "./files.js";
+export { allowedFile, listNotes, openExternal, OPENABLE, wikilinkTarget };
 /** pi as a child process in RPC mode. Strict JSONL: records end at LF only. */
 export class Agent {
     proc;
@@ -186,41 +187,6 @@ const TYPES = {
 const NOTE_TYPES = new Set([".md", ".markdown"]);
 /** Images that a note shows (a figure cut out of a PDF, for example). */
 const IMAGE_TYPES = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" };
-/** Files that the Open button may hand to the system (never programs or scripts). */
-export const OPENABLE = new Set([".md", ".markdown", ".txt", ".pdf", ".bib", ".csv", ".qmd"]);
-/** A file inside the working folder or the Sub-Sub folder, judged by its real path, so a link cannot point outside. */
-export function allowedFile(raw, cwd, vault) {
-    // expand() resolves against the process folder: use it for "~" only.
-    const target = resolve(cwd, raw.startsWith("~") ? expand(raw) : raw);
-    const real = realish(target);
-    const inside = within(real, realish(cwd)) || Boolean(vault && within(real, realish(vault)));
-    return inside && existsSync(target) && statSync(target).isFile() ? target : undefined;
-}
-/** The note a [[wikilink]] names: the first <folder>/<name>.md in the Sub-Sub folder, as Obsidian would find it. */
-export function wikilinkTarget(name, root) {
-    const file = name.endsWith(".md") ? name : `${name}.md`;
-    return ["", ...NOTE_DIRS, SETTINGS_DIR].map((d) => join(root, d, file)).find((f) => existsSync(f));
-}
-/** The notes in the Sub-Sub folders, newest first (dot folders such as Research/.plans left out). */
-export function listNotes(root, max = 300) {
-    const out = [];
-    for (const d of [...NOTE_DIRS, SETTINGS_DIR]) {
-        let names = [];
-        try {
-            names = readdirSync(join(root, d), { recursive: true });
-        }
-        catch {
-            continue;
-        }
-        for (const n of names) {
-            if (!n.endsWith(".md") || n.split(/[\\/]/).some((x) => x.startsWith(".")))
-                continue;
-            const path = join(root, d, n);
-            out.push({ path, rel: join(d, n), modified: statSync(path).mtimeMs });
-        }
-    }
-    return out.sort((a, b) => b.modified - a.modified).slice(0, max);
-}
 const CSP = [
     "default-src 'none'",
     "script-src 'self'",
@@ -285,20 +251,6 @@ function alive(pid) {
         return err.code === "EPERM";
     }
 }
-/** Open a URL or a file with the system's default program. */
-export function openExternal(target) {
-    const opts = { detached: true, stdio: "ignore", windowsHide: true };
-    let child;
-    if (process.platform === "darwin")
-        child = spawn("open", [target], opts);
-    // rundll32 hands the target to the default program without cmd.exe parsing it.
-    else if (process.platform === "win32")
-        child = spawn("rundll32", ["url.dll,FileProtocolHandler", target], opts);
-    else
-        child = spawn("xdg-open", [target], opts);
-    child.on("error", () => { });
-    child.unref();
-}
 /**
  * Start the web server and pi. Resolves when both are listening; the caller
  * decides whether to open a browser. Used by `subsub web` and by the tests.
@@ -741,10 +693,7 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
                     // Documents only: a file that the model wrote must never be run.
                     if (!OPENABLE.has(extname(target).toLowerCase()))
                         return send(res, 403, { error: "Sub-Sub opens only notes and documents (.md, .txt, .pdf, .bib, .csv, .qmd)." });
-                    if (vault && within(target, vault) && obsidianRoot(vault))
-                        openExternal(`obsidian://open?path=${encodeURIComponent(target)}`);
-                    else
-                        openExternal(target);
+                    openFile(target, vault);
                     return send(res, 200, { ok: true });
                 }
                 case "POST /api/quit":

package/dist/words.js

@@ -0,0 +1,26 @@
+/**
+ * The plain words of the web view (actions, suggestions, names of tools, in English and Portuguese), for the terminal screens.
+ * web/i18n.js is a browser module with no imports; it is loaded here as it is, so the two views never differ.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { PACKAGE_DIR } from "./cli.js";
+let words;
+/** A dynamic import: a static one would pull a file outside src/ into the TypeScript build. */
+export function loadWords() {
+    words ??= import(__rewriteRelativeImportExtension(pathToFileURL(join(PACKAGE_DIR, "web", "i18n.js")).href));
+    return words;
+}
+/** What a tool is called while it runs ("zotero_find_items" is "search the library"); unknown tools keep their name. */
+export function toolWord(w, lang, name) {
+    const short = name.replace(/^(zotero|scholar)_/, "");
+    return w.TOOLS[lang][short] ?? w.TOOLS.en[short] ?? name;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiagojct/subsub",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Sub-Sub: a research assistant that works from your own Zotero library, in the browser or the terminal, built on pi",
   "type": "module",
   "license": "MIT",

package/scripts/make-themes.mjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// Writes the pi themes of Sub-Sub (themes/subsub-<name>-<scheme>.json) from the colours in the front matter of
+// DESIGN.md and the role map in scripts/plate.json. The Researcher uses Prussian blue as its accent (glauca), the
+// Librarian madder (try-works). Errors have no colour of their own, removals are muted ink (the strike-through is
+// drawn by the code), and every meaning also has a glyph or a word, so the themes work for readers who do not see the washes.
+//
+//   node scripts/make-themes.mjs
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+const SCHEMA = "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json";
+
+/** The `colors:` block of the DESIGN.md front matter as {token: "#rrggbb"}. */
+export function designColors(markdown) {
+	const colors = {};
+	let inBlock = false;
+	for (const line of markdown.split("\n")) {
+		if (/^colors:\s*$/.test(line)) inBlock = true;
+		else if (inBlock && /^\S/.test(line)) break;
+		else if (inBlock) {
+			const m = line.match(/^\s+([a-z0-9-]+):\s*"(#[0-9a-fA-F]{6})"\s*$/);
+			if (m) colors[m[1]] = m[2].toLowerCase();
+		}
+	}
+	return colors;
+}
+
+
+const CUBE = [0, 95, 135, 175, 215, 255];
+/** The RGB of an xterm-256 colour index from 16 to 255 (the 16 system colours depend on the terminal). */
+export function xterm256(i) {
+	if (i >= 232) return [8 + (i - 232) * 10, 8 + (i - 232) * 10, 8 + (i - 232) * 10];
+	const n = i - 16;
+	return [CUBE[Math.floor(n / 36)], CUBE[Math.floor(n / 6) % 6], CUBE[n % 6]];
+}
+const toRgb = (h) => [1, 3, 5].map((k) => parseInt(h.slice(k, k + 2), 16));
+const luminance = (rgb) => {
+	const [r, g, b] = rgb.map((v) => v / 255).map((v) => (v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4));
+	return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+export function contrastRatio(a, b) {
+	const [hi, lo] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+	return (hi + 0.05) / (lo + 0.05);
+}
+
+/** The xterm-256 index nearest to a colour that reaches `min` contrast against `against` (the closest index with enough contrast, or the one with the most). */
+export function nearest256(hex, against, min) {
+	const want = toRgb(hex);
+	const ranked = [];
+	for (let i = 16; i < 256; i++) {
+		const c = xterm256(i);
+		ranked.push({ i, d: (c[0] - want[0]) ** 2 * 0.3 + (c[1] - want[1]) ** 2 * 0.59 + (c[2] - want[2]) ** 2 * 0.11, k: against ? contrastRatio(c, against) : Infinity });
+	}
+	ranked.sort((a, b) => a.d - b.d);
+	return (ranked.find((r) => r.k >= min) ?? ranked.sort((a, b) => b.k - a.k)[0]).i;
+}
+
+// Contrast that each colour variable needs against the terminal's own background: text 4.5, lines and bullets 3, rules none.
+const NEEDS = { ink: 4.5, muted: 4.5, faint: 4.5, prussian: 4.5, madder: 4.5, sap: 4.5, gamboge: 4.5, mark: 3, rule: 0 };
+// Roles whose background is left to the terminal in the 256-colour themes: a wash that is quantised to the cube loses its contrast.
+const DEFAULT_BG = ["userMessageBg", "customMessageBg", "toolPendingBg", "toolSuccessBg", "toolErrorBg", "searchMatchBg"];
+
+/** The same theme with xterm-256 indexes, for terminals without truecolor. */
+function to256(theme) {
+	const v = theme.vars;
+	const sheet = toRgb(v.sheet);
+	const vars = {};
+	for (const name of Object.keys(NEEDS)) vars[name] = nearest256(v[name], sheet, NEEDS[name]);
+	vars.accent = vars[Object.keys(NEEDS).find((n) => v[n] === v.accent)];
+	// The selection needs the text colour to stay readable on it.
+	vars.wash = nearest256(v.wash, xterm256(vars.ink), 4.5);
+	const colors = { ...theme.colors };
+	for (const r of DEFAULT_BG) colors[r] = "";
+	return { ...theme, name: `${theme.name}-256`, vars, colors, export: theme.export };
+}
+
+/** {"subsub-glauca-dark": theme, "subsub-glauca-dark-256": theme, ...} for every theme and scheme of the plate file. */
+export function buildThemes(designMd, plate) {
+	const design = designColors(designMd);
+	const out = {};
+	for (const [name, mode] of Object.entries(plate.themes)) {
+		for (const scheme of ["dark", "light"]) {
+			const vars = {};
+			for (const [v, key] of Object.entries(plate.tokens[scheme])) {
+				if (!design[key]) throw new Error(`DESIGN.md has no colour "${key}" (${scheme} ${v})`);
+				vars[v] = design[key];
+			}
+			vars.accent = vars[mode.accent];
+			vars.wash = vars[mode.wash];
+			const colors = {};
+			for (const [role, ref] of Object.entries(plate.roles)) colors[role] = ref === "$accent" ? "accent" : ref === "$wash" ? "wash" : ref;
+			const id = `subsub-${name}-${scheme}`;
+			out[id] = { $schema: SCHEMA, name: id, vars, colors, export: { pageBg: vars.sheet, cardBg: vars.field, infoBg: vars.sunk } };
+			out[`${id}-256`] = to256(out[id]);
+		}
+	}
+	return out;
+}
+
+function main() {
+	const design = fs.readFileSync(path.join(ROOT, "DESIGN.md"), "utf8");
+	const plate = JSON.parse(fs.readFileSync(path.join(ROOT, "scripts", "plate.json"), "utf8"));
+	fs.mkdirSync(path.join(ROOT, "themes"), { recursive: true });
+	for (const [id, theme] of Object.entries(buildThemes(design, plate))) {
+		fs.writeFileSync(path.join(ROOT, "themes", `${id}.json`), JSON.stringify(theme, null, "\t") + "\n");
+		console.log(`themes/${id}.json`);
+	}
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) main();