@turri-dev/cli 0.1.16-next.ce2cd46 → 0.1.17-next.1ecfd4f

package/dist/chats.js

@@ -0,0 +1,356 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { currentChat, inChat } from "./chat-scope.js";
+import { adoptRun, forgetChat, recordRun } from "./chat-records.js";
+import { createChatUi } from "./chat-ui.js";
+import { debugMode } from "./config.js";
+import { record } from "./regenerate/ledger.js";
+/**
+ * The chats of a turri session.
+ *
+ * One turri process is one session on one project, and holds up to MAX_CHATS chats: conversations, each with its own
+ * history, model, thinking level, stack and questions, each working while another is shown. What they share is the
+ * session's: the one job registry and work loop the project's pulses run in - a pulse any chat starts is in every
+ * chat's side panel - the coding model, steering, releases and the ledger.
+ *
+ * A chat is a pi session with turri's extension in it. The extension, built once for each, links itself to its chat
+ * here (`attach`); its tools, commands and handlers then run inside the chat's scope (chat-scope.ts), so a pulse knows
+ * which chat asked for it, and is reported back there when it ends - to the chat shown, when that one is closed.
+ *
+ * Where the chats live is a driver's: the terminal's (chat-terminal.ts) swaps which one pi's screen shows; a host's
+ * (`createTurri`) makes a session for each and shows them in its own windows.
+ */
+/** The most chats a session has open at once. */
+export const MAX_CHATS = 9;
+/** What a chat is called until something is said in it. */
+export const NEW_CHAT_TITLE = "new chat";
+/** A chat's title from what it says: its name, else its first message, short. */
+function titleOf(session) {
+    if (session === undefined)
+        return undefined;
+    try {
+        const named = session.sessionManager.getSessionName()?.trim();
+        if (named)
+            return named;
+        for (const message of session.messages) {
+            if (message.role !== "user")
+                continue;
+            const content = message.content;
+            const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => part.text ?? "").join(" ") : "";
+            const words = text.replace(/\s+/g, " ").trim();
+            if (words !== "")
+                return words.length > TITLE_CHARS ? `${words.slice(0, TITLE_CHARS - 1)}…` : words;
+        }
+    }
+    catch {
+        /* a session let go has no title to read */
+    }
+    return undefined;
+}
+const TITLE_CHARS = 32;
+export function createChats(options) {
+    const { cwd, host, jobs } = options;
+    const chats = [];
+    const listeners = new Set();
+    let driver;
+    let shownId;
+    /** The chat whose extension pi is building now. */
+    let attaching;
+    /** Chats are opened one at a time: each one's extension is built while it is the one attaching. */
+    let opening = Promise.resolve();
+    let notices = [];
+    const run = { run: randomUUID().slice(0, 8), pid: process.pid, started: new Date().toISOString(), chats: [] };
+    const changed = () => {
+        for (const listener of listeners) {
+            try {
+                listener();
+            }
+            catch {
+                /* a listener that fails is left out of this change */
+            }
+        }
+    };
+    /** A chat nothing was said in yet is a new chat: its number is beside it already, in the strip and the picker. */
+    const titleFor = (chat) => titleOf(chat.session) ?? chat.recordedTitle ?? NEW_CHAT_TITLE;
+    const statusOf = (chat) => (chat.ui?.waiting() ?? 0) > 0 ? "question" : chat.working ? "working" : chat.unread ? "unread" : "idle";
+    /** What the session keeps of its chats on disk: those with something said in them, in order. */
+    const persist = () => {
+        if (options.persist !== true)
+            return;
+        run.chats = chats.flatMap((chat) => {
+            const file = chat.session?.sessionFile;
+            return file !== undefined && existsSync(file) ? [{ id: chat.id, title: titleFor(chat), sessionFile: file }] : [];
+        });
+        recordRun(cwd, run, { keep: debugMode(cwd) });
+    };
+    const newChat = (title) => {
+        const id = randomUUID().slice(0, 8);
+        const chat = {
+            id,
+            scope: { id, stack: process.env.TURRI_STACK?.trim() || undefined },
+            ...(title !== undefined ? { recordedTitle: title } : {}),
+            working: false,
+            unread: false,
+        };
+        chat.dialogs = options.dialogs?.(id);
+        chats.push(chat);
+        return chat;
+    };
+    /** What the chat's session does, as the session follows it: its turns, its name. */
+    const follow = (chat) => {
+        chat.unsubscribe?.();
+        const session = chat.session;
+        if (session === undefined)
+            return;
+        chat.unsubscribe = session.subscribe((event) => {
+            if (event.type === "agent_start") {
+                chat.working = true;
+                changed();
+            }
+            else if (event.type === "agent_end") {
+                chat.working = false;
+                if (shownId !== chat.id)
+                    chat.unread = true;
+                persist();
+                changed();
+            }
+            else if (event.type === "session_info_changed") {
+                persist();
+                changed();
+            }
+        });
+    };
+    const core = {
+        cwd,
+        host,
+        jobs,
+        extension: (pi) => options.extension(pi, core.attach(pi)),
+        get canOpen() {
+            return driver !== undefined;
+        },
+        get terminal() {
+            return driver?.terminal === true;
+        },
+        chats: () => chats.map((chat) => ({ id: chat.id, title: titleFor(chat), status: statusOf(chat), shown: chat.id === shownId })),
+        session: (id) => chats.find((chat) => chat.id === id)?.session,
+        shown: () => shownId,
+        shownChat: () => chats.find((chat) => chat.id === shownId),
+        chatOfSession: (session) => chats.find((chat) => chat.session === session),
+        async open(asked = {}) {
+            if (driver === undefined)
+                throw new Error("This turri has one chat: there is nowhere to open another.");
+            const done = opening.then(async () => {
+                const already = asked.sessionFile !== undefined ? chats.find((chat) => chat.session?.sessionFile === asked.sessionFile) : undefined;
+                if (already !== undefined)
+                    return already;
+                if (chats.length >= MAX_CHATS)
+                    throw new Error(`${MAX_CHATS} chats are open, the most there can be: close one first.`);
+                const chat = newChat(asked.title);
+                attaching = chat;
+                try {
+                    await driver.create(chat, asked.sessionFile);
+                }
+                catch (error) {
+                    chats.splice(chats.indexOf(chat), 1);
+                    throw error;
+                }
+                finally {
+                    attaching = undefined;
+                }
+                follow(chat);
+                inChat(chat.scope, () => record({ kind: "chat.opened", reopened: asked.sessionFile !== undefined }, { project: cwd }));
+                persist();
+                changed();
+                return chat;
+            });
+            opening = done.catch(() => undefined);
+            const chat = await done;
+            if (asked.hidden !== true)
+                await core.show(chat.id);
+            return core.chats().find((info) => info.id === chat.id);
+        },
+        async close(id) {
+            const index = chats.findIndex((chat) => chat.id === id);
+            if (index === -1)
+                return;
+            const chat = chats[index];
+            if (shownId === id) {
+                const next = chats[index + 1] ?? chats[index - 1];
+                if (next !== undefined)
+                    await core.show(next.id);
+                else
+                    shownId = undefined;
+            }
+            const recorded = run.chats.find((kept) => kept.id === id);
+            chats.splice(chats.indexOf(chat), 1);
+            chat.unsubscribe?.();
+            chat.ui?.close();
+            inChat(chat.scope, () => record({ kind: "chat.closed" }, { project: cwd }));
+            try {
+                await driver?.dispose(chat);
+            }
+            finally {
+                if (options.persist === true) {
+                    forgetChat(cwd, run.run, recorded, { keep: debugMode(cwd) });
+                    run.chats = run.chats.filter((kept) => kept.id !== id);
+                }
+                changed();
+            }
+        },
+        async show(id) {
+            const chat = chats.find((candidate) => candidate.id === id);
+            if (chat === undefined || shownId === id)
+                return;
+            const from = core.shownChat();
+            if (driver?.show !== undefined)
+                await driver.show(chat, from);
+            else
+                core.showing(chat);
+        },
+        showing(chat) {
+            shownId = chat.id;
+            chat.unread = false;
+            for (const [message, level] of notices.splice(0))
+                core.notify(message, level);
+            changed();
+        },
+        onChats(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        changed,
+        notify(message, level) {
+            const chat = core.shownChat();
+            const ui = chat?.ui?.ui ?? chat?.session?.extensionRunner.getUIContext();
+            if (ui === undefined) {
+                notices = [...notices, [message, level]].slice(-10);
+                return;
+            }
+            try {
+                ui.notify(message, level);
+            }
+            catch {
+                /* a chat let go says nothing */
+            }
+        },
+        async dispose(asked = {}) {
+            for (const chat of chats.splice(0)) {
+                chat.unsubscribe?.();
+                chat.ui?.close();
+                if (chat.session === asked.except)
+                    continue;
+                try {
+                    await driver?.dispose(chat);
+                }
+                catch {
+                    /* let go already */
+                }
+            }
+            changed();
+        },
+        attach() {
+            // The chat pi builds this extension for: the one being opened; else, the session's first - pi makes it itself -
+            // or, once there is one, the chat shown, rebuilt by pi (a /reload, a /fork).
+            const chat = attaching ?? core.shownChat() ?? (chats.length === 0 ? newChat() : chats[chats.length - 1]);
+            return {
+                id: chat.id,
+                scope: chat.scope,
+                dialogs: chat.dialogs,
+                live: (instance) => {
+                    chat.instance = instance;
+                },
+            };
+        },
+        adopt(session, services) {
+            const chat = core.chatOfSession(session) ?? core.shownChat() ?? chats.find((candidate) => candidate.session === undefined) ?? newChat();
+            if (chat.session !== session) {
+                chat.session = session;
+                chat.services = services;
+                follow(chat);
+                if (shownId === undefined)
+                    inChat(chat.scope, () => record({ kind: "chat.opened", reopened: session.messages.length > 0 }, { project: cwd }));
+            }
+            return chat;
+        },
+        jobFinished(job) {
+            const asked = chats.find((chat) => chat.id === job.chat);
+            const chat = asked?.instance !== undefined ? asked : (core.shownChat() ?? chats[0]);
+            if (chat === undefined)
+                return;
+            if (chat.id !== shownId)
+                chat.unread = true;
+            try {
+                chat.instance?.announce(job);
+            }
+            catch {
+                // A chat let go as the pulse ended: the one shown is told instead.
+                const shown = core.shownChat();
+                if (shown !== undefined && shown !== chat)
+                    shown.instance?.announce(job);
+            }
+            changed();
+        },
+        jobsChanged() {
+            for (const chat of chats) {
+                try {
+                    chat.instance?.jobsChanged();
+                }
+                catch {
+                    /* a chat let go draws nothing */
+                }
+            }
+        },
+        instanceInScope() {
+            const scoped = currentChat();
+            return (chats.find((chat) => chat.id === scoped?.id) ?? core.shownChat() ?? chats[0])?.instance;
+        },
+        setDriver(given) {
+            driver = given;
+        },
+        async restore(saved, asked = {}) {
+            adoptRun(cwd, saved.run);
+            const [first, ...rest] = saved.chats;
+            if (first !== undefined && asked.skipFirst === true) {
+                const chat = chats[0];
+                if (chat !== undefined)
+                    chat.recordedTitle ??= first.title;
+            }
+            for (const kept of asked.skipFirst === true ? rest : saved.chats) {
+                try {
+                    await core.open({ sessionFile: kept.sessionFile, hidden: true, title: kept.title });
+                }
+                catch (error) {
+                    core.notify(`The chat "${kept.title}" could not be reopened: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                }
+            }
+            persist();
+        },
+    };
+    return core;
+}
+/**
+ * pi's extension API for a chat: every tool, command, shortcut and handler the extension registers runs inside the
+ * chat's scope - its stack, and its id on what it starts.
+ */
+export function scopedToChat(pi, scope) {
+    const within = (work) => work === undefined ? undefined : (...args) => inChat(scope, () => work(...args));
+    return new Proxy(pi, {
+        get(target, key, receiver) {
+            if (key === "registerTool")
+                return (tool) => target.registerTool({ ...tool, execute: within(tool.execute) });
+            if (key === "registerCommand")
+                return (name, command) => target.registerCommand(name, { ...command, handler: within(command.handler) });
+            if (key === "registerShortcut")
+                return (shortcut, options) => target.registerShortcut(shortcut, { ...options, handler: within(options.handler) });
+            if (key === "on")
+                return (event, handler) => target.on(event, within(handler));
+            const value = Reflect.get(target, key, receiver);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}
+/** A chat's stand-in for the screen, for the terminal's driver. */
+export function terminalUi(chat, screen, onChange) {
+    chat.ui ??= createChatUi({ screen, onChange });
+    return chat.ui;
+}

package/dist/cli.js

@@ -52,11 +52,9 @@ function chat(args) {
     }
     // pi itself, through a launcher that leaves out pi's startup header - see pi-launch.ts.
     const launcher = join(HERE, `pi-launch${OWN_EXTENSION}`);
-    // Loading the same extension twice is an error in pi, not a no-op, so the explicit -e is left out while an older
-    // turri's file still loads turri into every pi - turri doctor offers to remove it.
-    const extension = extensionInstalledGlobally()
-        ? []
-        : ["-e", join(HERE, `extension${OWN_EXTENSION}`)];
+    // turri is built into pi by the launcher - unless an older turri's file still loads it into every pi, which builds it
+    // in as well: pi-launch.ts is told, and leaves it to that. turri doctor offers to remove the file.
+    const inPi = extensionInstalledGlobally();
     const themes = themesInstalledGlobally() ? [] : ["--theme", join(PACKAGE_ROOT, ".pi", "themes")];
     // turri's own theme, unless this run names another. For this run only: pi's settings
     // are left as they are, so a plain `pi` keeps its theme.
@@ -66,10 +64,10 @@ function chat(args) {
     // Fullscreen: pi owns the viewport, so the conversation stays where it is scrolled to while the
     // jobs redraw - in the terminal's own scrollback, every redraw pulls it back to the bottom.
     const tuiMode = args.some((arg) => arg === "--tui-mode" || arg.startsWith("--tui-mode=")) ? [] : ["--tui-mode", "fullscreen"];
-    const result = spawnSync(process.execPath, [launcher, ...extension, ...themes, ...useTheme, ...tuiMode, ...piArgs], {
+    const result = spawnSync(process.execPath, [launcher, ...themes, ...useTheme, ...tuiMode, ...piArgs], {
         stdio: "inherit",
         cwd: process.cwd(),
-        env: codingModel ? { ...process.env, [CODING_MODEL_ENV]: codingModel } : process.env,
+        env: { ...process.env, ...(codingModel ? { [CODING_MODEL_ENV]: codingModel } : {}), ...(inPi ? { TURRI_EXTENSION_IN_PI: "1" } : {}) },
     });
     process.exit(result.status ?? 1);
 }

package/dist/config.d.ts

@@ -85,9 +85,15 @@ export declare function stacksOf(root: string): string[];
 export declare function adoptLegacyConfig(root: string, options?: {
     projectFile?: boolean;
 }): string[];
-/** The stack chosen now - `/stack`, `--stack`, `TURRI_STACK` - or, inside a pulse, the one it started with. */
+/**
+ * The stack chosen now - the chat's own (`/stack` in it), else `--stack` or `TURRI_STACK` - or, inside a pulse, the one
+ * it started with.
+ */
 export declare function chosenStack(): string | undefined;
-/** Choose the stack everything is built with from now on - or none, the project's config alone. Kept in TURRI_STACK. */
+/**
+ * Choose the stack everything is built with from now on - or none, the project's config alone. In a chat, for that
+ * chat alone; outside one, kept in TURRI_STACK.
+ */
 export declare function chooseStack(stack: string | undefined): void;
 /** Run `work` with `stack` as the one chosen, whatever is chosen meanwhile: a pulse keeps the stack it started with. */
 export declare function withStack<T>(stack: string | undefined, work: () => T): T;

package/dist/config.js

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { copyFileSync, existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { load as loadYaml } from "js-yaml";
+import { currentChat } from "./chat-scope.js";
 import { projectDirOf } from "./regenerate/paths.js";
 /**
  * The project's `config.turri.yaml`, at its root - the folder that holds `plain_modules` - or, before it had one, its `config.yaml`.
@@ -139,19 +140,32 @@ export function adoptLegacyConfig(root, options = {}) {
 }
 /** The stack a pulse runs with: the one chosen as it started, whatever is chosen since. */
 const pinnedStack = new AsyncLocalStorage();
-/** The stack chosen now - `/stack`, `--stack`, `TURRI_STACK` - or, inside a pulse, the one it started with. */
+/**
+ * The stack chosen now - the chat's own (`/stack` in it), else `--stack` or `TURRI_STACK` - or, inside a pulse, the one
+ * it started with.
+ */
 export function chosenStack() {
     const pinned = pinnedStack.getStore();
     if (pinned !== undefined)
         return pinned.stack;
+    const chat = currentChat();
+    if (chat !== undefined)
+        return chat.stack;
     return text(process.env.TURRI_STACK);
 }
-/** Choose the stack everything is built with from now on - or none, the project's config alone. Kept in TURRI_STACK. */
+/**
+ * Choose the stack everything is built with from now on - or none, the project's config alone. In a chat, for that
+ * chat alone; outside one, kept in TURRI_STACK.
+ */
 export function chooseStack(stack) {
-    if (stack === undefined || stack.trim() === "")
+    const chosen = stack === undefined || stack.trim() === "" ? undefined : stack.trim();
+    const chat = currentChat();
+    if (chat !== undefined)
+        chat.stack = chosen;
+    else if (chosen === undefined)
         delete process.env.TURRI_STACK;
     else
-        process.env.TURRI_STACK = stack.trim();
+        process.env.TURRI_STACK = chosen;
 }
 /** Run `work` with `stack` as the one chosen, whatever is chosen meanwhile: a pulse keeps the stack it started with. */
 export function withStack(stack, work) {

package/dist/extension.d.ts

@@ -1,11 +1,11 @@
 import "./terminal-images.ts";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import { stackOnMachine } from "./stack.ts";
 import { createAskUserTool } from "./tools.ts";
 import { fromWorkingDir } from "./loop-tools.ts";
 import { type WorkLoop } from "./regenerate/loop.ts";
 import { type AskUser, type AskUserIO } from "./ask.ts";
-import { type Job, type JobRegistry } from "./regenerate/jobs.ts";
+import { type TurriCore, type TurriHost } from "./chats.ts";
 /**
  * Puts a skill step's question to the person, when there is one to ask.
  *
@@ -29,38 +29,25 @@ dialogs?: AskUserIO): AskUser;
  * to start at once.
  */
 export declare function chatAskUserTool(dialogs?: AskUserIO, afterAnswer?: (answer: string) => string | undefined): ReturnType<typeof createAskUserTool>;
+export type { TurriHost } from "./chats.ts";
 /**
- * What a host that runs turri's conversation itself - a desktop app, an editor - is told and asked, where the terminal
- * would draw: the conversation's jobs and its work loop as they are made and as they change, and the dialogs its
- * questions are put to the person in. A host gives the extension `createTurriExtension(host)`; `turri` gives it none.
- */
-export interface TurriHost {
-    /** The conversation's job registry, as the extension makes it: every pulse the conversation starts is in it. */
-    onJobs?(jobs: JobRegistry): void;
-    /** The conversation's work loop, once work is first asked for: what each codebase has planned, and why. */
-    onWorkLoop?(loop: WorkLoop): void;
-    /** A job started, moved to another stage, did something, or ended. */
-    onJobChange?(job: Job): void;
-    /** What is planned changed with no job - a module being planned, or planned. */
-    onPlanChange?(): void;
-    /** The dialogs ask_user puts its questions in - the conversation's and a skill's interview - instead of the terminal's. */
-    dialogs?: AskUserIO;
-    /**
-     * The host's own UI, in its own words: the views it has in place of the terminal's, what its marks and buttons mean,
-     * where questions appear. Given, turri tells the model none of the terminal's - its keys, the side panel, regen,
-     * /pulses - and gives it this instead, as a `<surface>` block in turri's identity. Absent, the terminal is the surface.
-     */
-    surface?: string;
-    /**
-     * The last word on the whole system prompt, as turri has built it for this turn - after its own before_agent_start
-     * work: what it returns is what is sent. For a host that needs to change anything else.
-     */
-    systemPrompt?(prompt: string): string;
-}
-/** turri's conversation as an extension of pi's, for a host that runs it itself: see TurriHost. */
-export declare function createTurriExtension(host?: TurriHost): (pi: ExtensionAPI) => void;
-declare const _default: (pi: ExtensionAPI) => void;
-export default _default;
+ * A turri session: its job registry and work loop, the ledger, and its chats, each with turri's extension in it
+ * (chats.ts). The terminal makes one as it starts (pi-launch.ts), a host with `createTurri` (host.ts); `persist`
+ * records the open chats for `turri --continue`.
+ */
+export declare function createTurriCore(host?: TurriHost, options?: {
+    persist?: boolean;
+    dialogs?: (chat: string) => AskUserIO | undefined;
+}): TurriCore;
+/** The session of this process: pi-launch.ts's, or one made as pi first builds the extension (`pi -e src/extension.ts`). */
+export declare function processSession(make?: () => TurriCore): TurriCore;
+declare const extension: ExtensionFactory;
+export default extension;
+/**
+ * The session's work loop, for a host to read: made with the first chat's context - the models it plans with - when no
+ * chat has asked for work yet.
+ */
+export declare function sessionLoop(session: TurriCore): WorkLoop;
 /**
  * What a slash command showed the person: kept in the chat, where they read it, and put in the conversation as well -
  * unseen there - so that when they speak of it next ("fix it"), the agent knows what they saw. A command runs outside