pi-ui-extend 0.1.32 → 0.1.34

package/dist/bundled-extensions/session-title/config.js

@@ -0,0 +1,150 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, parse, resolve } from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+const DEFAULT_CONFIG = {
+    enabled: true,
+    model: "zai/glm-4.5-air",
+    fallbackModels: [],
+    maxInputChars: 2000,
+    maxTitleChars: 80,
+    maxTokens: 32,
+    maxRetries: 2,
+    generationAttempts: 3,
+    retryDelayMs: 3000,
+    timeoutMs: 12_000,
+    terminalTitle: true,
+    terminalTitlePrefix: "pi — ",
+    notify: false,
+    debug: false,
+};
+const PIX_CONFIG_FILE = "pix.jsonc";
+const SESSION_TITLE_CONFIG_FILE = "session-title.jsonc";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readJsonc(filePath) {
+    if (!existsSync(filePath))
+        return {};
+    try {
+        const parsed = parseJsonc(readFileSync(filePath, "utf8"));
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function mergeConfig(base, raw) {
+    const next = { ...base };
+    if (typeof raw.enabled === "boolean")
+        next.enabled = raw.enabled;
+    const model = readNonEmptyString(raw.modelRef) ?? readNonEmptyString(raw.model);
+    if (model)
+        next.model = model;
+    const fallbackModels = readModelList(raw.fallbackModels);
+    if (fallbackModels)
+        next.fallbackModels = fallbackModels;
+    if (typeof raw.terminalTitle === "boolean")
+        next.terminalTitle = raw.terminalTitle;
+    if (typeof raw.terminalTitlePrefix === "string")
+        next.terminalTitlePrefix = raw.terminalTitlePrefix;
+    if (typeof raw.notify === "boolean")
+        next.notify = raw.notify;
+    if (typeof raw.debug === "boolean")
+        next.debug = raw.debug;
+    if (typeof raw.maxInputChars === "number" && Number.isFinite(raw.maxInputChars)) {
+        next.maxInputChars = Math.max(100, Math.floor(raw.maxInputChars));
+    }
+    if (typeof raw.maxTitleChars === "number" && Number.isFinite(raw.maxTitleChars)) {
+        next.maxTitleChars = Math.max(20, Math.floor(raw.maxTitleChars));
+    }
+    if (typeof raw.maxTokens === "number" && Number.isFinite(raw.maxTokens)) {
+        next.maxTokens = Math.max(8, Math.floor(raw.maxTokens));
+    }
+    if (typeof raw.maxRetries === "number" && Number.isFinite(raw.maxRetries)) {
+        next.maxRetries = Math.max(0, Math.floor(raw.maxRetries));
+    }
+    if (typeof raw.generationAttempts === "number" && Number.isFinite(raw.generationAttempts)) {
+        next.generationAttempts = Math.max(1, Math.floor(raw.generationAttempts));
+    }
+    if (typeof raw.retryDelayMs === "number" && Number.isFinite(raw.retryDelayMs)) {
+        next.retryDelayMs = Math.max(250, Math.floor(raw.retryDelayMs));
+    }
+    if (typeof raw.timeoutMs === "number" && Number.isFinite(raw.timeoutMs)) {
+        next.timeoutMs = Math.max(1000, Math.floor(raw.timeoutMs));
+    }
+    return next;
+}
+function readNonEmptyString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function readModelList(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value
+        .map((item) => readNonEmptyString(item))
+        .filter((item) => item !== undefined);
+}
+function readPixSessionTitleConfig(configDir) {
+    const pixConfig = readJsonc(join(configDir, PIX_CONFIG_FILE));
+    return isRecord(pixConfig.sessionTitle) ? pixConfig.sessionTitle : {};
+}
+function applyEnv(config) {
+    let next = { ...config };
+    if (["1", "true", "on", "yes"].includes((process.env.PI_OFFLINE ?? "").trim().toLowerCase())) {
+        next.enabled = false;
+    }
+    const enabled = process.env.PI_SESSION_TITLE_ENABLED;
+    if (enabled !== undefined)
+        next.enabled = !["0", "false", "off", "no"].includes(enabled.trim().toLowerCase());
+    const model = process.env.PI_SESSION_TITLE_MODEL;
+    if (model?.trim())
+        next.model = model.trim();
+    if (process.env.PI_SESSION_TITLE_TERMINAL_TITLE !== undefined) {
+        next.terminalTitle = ["1", "true", "on", "yes"].includes(process.env.PI_SESSION_TITLE_TERMINAL_TITLE.trim().toLowerCase());
+    }
+    if (process.env.PI_SESSION_TITLE_TERMINAL_PREFIX !== undefined) {
+        next.terminalTitlePrefix = process.env.PI_SESSION_TITLE_TERMINAL_PREFIX;
+    }
+    if (process.env.PI_SESSION_TITLE_NOTIFY !== undefined) {
+        next.notify = ["1", "true", "on", "yes"].includes(process.env.PI_SESSION_TITLE_NOTIFY.trim().toLowerCase());
+    }
+    if (process.env.PI_SESSION_TITLE_DEBUG !== undefined) {
+        next.debug = ["1", "true", "on", "yes"].includes(process.env.PI_SESSION_TITLE_DEBUG.trim().toLowerCase());
+    }
+    return next;
+}
+function findProjectConfig(startDir) {
+    let dir = resolve(startDir);
+    const root = parse(dir).root;
+    while (true) {
+        const candidate = join(dir, ".pi", "session-title.jsonc");
+        if (existsSync(candidate))
+            return candidate;
+        if (dir === root)
+            return undefined;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+export function loadSessionTitleConfig(projectDir) {
+    let config = { ...DEFAULT_CONFIG };
+    const homeConfigDir = join(homedir(), ".config", "pi");
+    config = mergeConfig(config, readPixSessionTitleConfig(homeConfigDir));
+    config = mergeConfig(config, readJsonc(join(homeConfigDir, SESSION_TITLE_CONFIG_FILE)));
+    const piConfigDir = process.env.PI_CONFIG_DIR;
+    if (piConfigDir) {
+        config = mergeConfig(config, readPixSessionTitleConfig(piConfigDir));
+        config = mergeConfig(config, readJsonc(join(piConfigDir, SESSION_TITLE_CONFIG_FILE)));
+    }
+    const projectConfig = findProjectConfig(projectDir);
+    if (projectConfig) {
+        config = mergeConfig(config, readJsonc(projectConfig));
+    }
+    return applyEnv(config);
+}

package/dist/bundled-extensions/session-title/index.d.ts

@@ -0,0 +1,5 @@
+import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+export { fallbackSessionTitleFromInput, generateSessionTitle, sessionTitleModelRefs, sanitizeSessionTitle } from "./title-generation.js";
+export declare function firstUserMessageText(ctx: ExtensionContext): string | undefined;
+export declare function buildForkTitleInput(parentTitle: string | undefined, forkPrompt: string): string;
+export default function sessionTitle(pi: ExtensionAPI): void;

package/dist/bundled-extensions/session-title/index.js

@@ -0,0 +1,384 @@
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { resolve } from "node:path";
+import { loadSessionTitleConfig } from "./config.js";
+import { fallbackSessionTitleFromInput, firstUserMessageText as firstUserMessageTextFromEntries, generateSessionTitle, sessionTitleModelRefs, } from "./title-generation.js";
+export { fallbackSessionTitleFromInput, generateSessionTitle, sessionTitleModelRefs, sanitizeSessionTitle } from "./title-generation.js";
+const DEFAULT_TERMINAL_TITLE = "pi";
+function imageAttachmentLabel(images) {
+    if (images.length === 0)
+        return undefined;
+    return images.length === 1 ? "Attached image" : `Attached images (${images.length})`;
+}
+function fallbackTitleInputFromPrompt(text, images = []) {
+    const trimmedText = text.trim();
+    return trimmedText || imageAttachmentLabel(images);
+}
+function titleGenerationInputFromPrompt(text, images = []) {
+    const trimmedText = text.trim();
+    const imageLabel = imageAttachmentLabel(images);
+    if (trimmedText && imageLabel)
+        return `${trimmedText}\n\n${imageLabel}`;
+    return trimmedText || imageLabel;
+}
+export function firstUserMessageText(ctx) {
+    return firstUserMessageTextFromEntries(ctx.sessionManager.getBranch());
+}
+function hasExistingUserMessage(ctx) {
+    return firstUserMessageText(ctx) !== undefined;
+}
+function truncateInput(text, maxChars) {
+    const trimmed = text.trim();
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars).trimEnd()}…`;
+}
+function terminalSafeText(text) {
+    return text
+        .replace(/[\u0000-\u001f\u007f]/gu, " ")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+export function buildForkTitleInput(parentTitle, forkPrompt) {
+    const prompt = forkPrompt.trim();
+    const parent = parentTitle?.trim();
+    if (!parent)
+        return prompt;
+    return [
+        "Parent session title:",
+        parent,
+        "",
+        "First prompt in this fork:",
+        prompt,
+    ].join("\n");
+}
+export default function sessionTitle(pi) {
+    let config;
+    let sessionId;
+    let controller;
+    let lastRenderedName;
+    let lastRenderedTitle;
+    let retryTimer;
+    const refreshTimers = new Set();
+    let pendingGeneration;
+    let forkTitleState;
+    function abortCurrentRequest() {
+        controller?.abort();
+        controller = undefined;
+    }
+    function clearRetryTimer() {
+        if (!retryTimer)
+            return;
+        clearTimeout(retryTimer);
+        retryTimer = undefined;
+    }
+    function clearRefreshTimers() {
+        for (const timer of refreshTimers)
+            clearTimeout(timer);
+        refreshTimers.clear();
+    }
+    function currentSessionName(ctx) {
+        const name = pi.getSessionName() ?? ctx?.sessionManager.getSessionName?.();
+        return name?.trim() || undefined;
+    }
+    function shouldGeneratePendingTitle(ctx) {
+        if (!pendingGeneration)
+            return false;
+        if (pendingGeneration.sessionId !== ctx.sessionManager.getSessionId())
+            return false;
+        const name = currentSessionName(ctx);
+        if (!name)
+            return true;
+        if (pendingGeneration.provisionalSessionName && name === pendingGeneration.provisionalSessionName)
+            return true;
+        return Boolean(pendingGeneration.replaceSessionName && name === pendingGeneration.replaceSessionName);
+    }
+    function advancePendingGeneration(currentConfig) {
+        if (!pendingGeneration)
+            return false;
+        while (pendingGeneration.attempts >= currentConfig.generationAttempts) {
+            if (pendingGeneration.modelIndex >= pendingGeneration.modelRefs.length - 1)
+                return false;
+            pendingGeneration.modelIndex++;
+            pendingGeneration.attempts = 0;
+        }
+        return pendingGeneration.modelIndex < pendingGeneration.modelRefs.length;
+    }
+    function renderTerminalTitle(ctx, name, force = false) {
+        if (!ctx.hasUI || !config?.enabled || !config.terminalTitle)
+            return;
+        const title = name ? `${config.terminalTitlePrefix}${name}` : DEFAULT_TERMINAL_TITLE;
+        const safeTitle = terminalSafeText(title) || DEFAULT_TERMINAL_TITLE;
+        if (!force && safeTitle === lastRenderedTitle)
+            return;
+        ctx.ui.setTitle(safeTitle);
+        lastRenderedTitle = safeTitle;
+    }
+    function refreshSessionUi(ctx, options = {}) {
+        const name = currentSessionName(ctx);
+        const nameChanged = name !== lastRenderedName;
+        if (options.force || nameChanged) {
+            lastRenderedName = name;
+        }
+        if (options.force || options.reapplyTitle || nameChanged) {
+            renderTerminalTitle(ctx, name, options.force || options.reapplyTitle);
+        }
+    }
+    function scheduleSessionUiRefresh(ctx) {
+        if (!ctx.hasUI)
+            return;
+        clearRefreshTimers();
+        for (const delayMs of [0, 100, 500, 1500, 3000]) {
+            const timer = setTimeout(() => {
+                refreshTimers.delete(timer);
+                refreshSessionUi(ctx, { reapplyTitle: true });
+            }, delayMs);
+            timer.unref?.();
+            refreshTimers.add(timer);
+        }
+    }
+    function scheduleGenerationRetry(ctx, currentConfig) {
+        clearRetryTimer();
+        if (!pendingGeneration)
+            return;
+        if (!shouldGeneratePendingTitle(ctx))
+            return;
+        if (!advancePendingGeneration(currentConfig))
+            return;
+        retryTimer = setTimeout(() => {
+            retryTimer = undefined;
+            startTitleGeneration(ctx, currentConfig);
+        }, currentConfig.retryDelayMs);
+        retryTimer.unref?.();
+    }
+    function applyFallbackSessionTitle(ctx, currentConfig, input, options = {}) {
+        const currentName = currentSessionName(ctx);
+        if (!options.force && currentName)
+            return false;
+        const fallbackTitle = fallbackSessionTitleFromInput(input, currentConfig.maxTitleChars);
+        if (!fallbackTitle)
+            return false;
+        pi.setSessionName(fallbackTitle);
+        refreshSessionUi(ctx, { force: true });
+        scheduleSessionUiRefresh(ctx);
+        return true;
+    }
+    function startTitleGeneration(ctx, currentConfig) {
+        if (!pendingGeneration)
+            return;
+        if (controller)
+            return;
+        if (!shouldGeneratePendingTitle(ctx))
+            return;
+        if (!advancePendingGeneration(currentConfig)) {
+            applyFallbackSessionTitle(ctx, currentConfig, pendingGeneration.input, {
+                force: Boolean(pendingGeneration.replaceSessionName),
+            });
+            pendingGeneration = undefined;
+            return;
+        }
+        const modelRef = pendingGeneration.modelRefs[pendingGeneration.modelIndex];
+        if (!modelRef) {
+            pendingGeneration = undefined;
+            return;
+        }
+        pendingGeneration.attempts++;
+        abortCurrentRequest();
+        controller = new AbortController();
+        const requestController = controller;
+        const currentSessionId = pendingGeneration.sessionId;
+        const generation = { ...pendingGeneration, modelRef };
+        void (async () => {
+            try {
+                const title = await generateSessionTitle(generation.input, ctx.modelRegistry, currentConfig, generation.modelRef, requestController.signal, currentConfig.debug && ctx.hasUI ? (message) => ctx.ui.notify(message, "warning") : undefined);
+                if (!title || requestController.signal.aborted)
+                    return;
+                if (sessionId !== currentSessionId)
+                    return;
+                if (!shouldGeneratePendingTitle(ctx))
+                    return;
+                pi.setSessionName(title);
+                pendingGeneration = undefined;
+                refreshSessionUi(ctx, { force: true });
+                scheduleSessionUiRefresh(ctx);
+                if (currentConfig.notify && ctx.hasUI)
+                    ctx.ui.notify(`Session named: ${title}`, "info");
+            }
+            catch (error) {
+                if (requestController.signal.aborted)
+                    return;
+                if (currentConfig.debug && ctx.hasUI) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    ctx.ui.notify(`Session title generation failed: ${message}`, "warning");
+                }
+            }
+            finally {
+                if (controller === requestController)
+                    controller = undefined;
+                if (requestController.signal.aborted || pendingGeneration?.sessionId !== currentSessionId)
+                    return;
+                if (shouldGeneratePendingTitle(ctx)) {
+                    if (!advancePendingGeneration(currentConfig)) {
+                        applyFallbackSessionTitle(ctx, currentConfig, generation.input, {
+                            force: Boolean(generation.replaceSessionName),
+                        });
+                        pendingGeneration = undefined;
+                        return;
+                    }
+                    scheduleGenerationRetry(ctx, currentConfig);
+                    return;
+                }
+            }
+        })();
+    }
+    function isSameSessionPath(left, right) {
+        if (!left || !right)
+            return false;
+        if (left === right)
+            return true;
+        try {
+            return resolve(left) === resolve(right);
+        }
+        catch {
+            return false;
+        }
+    }
+    async function resolveParentSessionTitle(options) {
+        const { parentSessionFile, cwd, sessionDir, fallbackTitle } = options;
+        if (!parentSessionFile)
+            return fallbackTitle;
+        try {
+            const directParentName = SessionManager.open(parentSessionFile).getSessionName()?.trim();
+            if (directParentName)
+                return directParentName;
+            const sessions = await SessionManager.list(cwd, sessionDir);
+            const parent = sessions.find((info) => isSameSessionPath(info.path, parentSessionFile));
+            const parentName = parent?.name?.trim();
+            if (parentName)
+                return parentName;
+        }
+        catch {
+            // Ignore lookup failures and keep the inherited session name as fallback.
+        }
+        return fallbackTitle;
+    }
+    function prepareForkTitleState(event, ctx) {
+        forkTitleState = undefined;
+        if (event.reason !== "fork")
+            return;
+        const currentSessionId = ctx.sessionManager.getSessionId();
+        const inheritedSessionName = currentSessionName(ctx);
+        const parentSessionFile = event.previousSessionFile ?? ctx.sessionManager.getHeader()?.parentSession;
+        const cwd = ctx.cwd;
+        const sessionDir = ctx.sessionManager.getSessionDir();
+        forkTitleState = {
+            sessionId: currentSessionId,
+            parentTitle: inheritedSessionName,
+            inheritedSessionName,
+        };
+        void resolveParentSessionTitle({
+            parentSessionFile,
+            cwd,
+            sessionDir,
+            fallbackTitle: inheritedSessionName,
+        }).then((parentTitle) => {
+            if (sessionId !== currentSessionId)
+                return;
+            if (forkTitleState?.sessionId !== currentSessionId)
+                return;
+            forkTitleState = {
+                sessionId: currentSessionId,
+                parentTitle,
+                inheritedSessionName,
+            };
+        });
+    }
+    pi.on("session_start", async (event, ctx) => {
+        abortCurrentRequest();
+        clearRetryTimer();
+        clearRefreshTimers();
+        config = loadSessionTitleConfig(ctx.cwd);
+        sessionId = ctx.sessionManager.getSessionId();
+        pendingGeneration = undefined;
+        forkTitleState = undefined;
+        lastRenderedName = undefined;
+        lastRenderedTitle = undefined;
+        refreshSessionUi(ctx, { force: true });
+        scheduleSessionUiRefresh(ctx);
+        prepareForkTitleState(event, ctx);
+    });
+    pi.on("session_shutdown", async () => {
+        abortCurrentRequest();
+        clearRetryTimer();
+        clearRefreshTimers();
+        forkTitleState = undefined;
+    });
+    function refreshOnEvent(ctx) {
+        refreshSessionUi(ctx);
+        scheduleSessionUiRefresh(ctx);
+    }
+    pi.on("agent_start", async (_event, ctx) => refreshOnEvent(ctx));
+    pi.on("agent_end", async (_event, ctx) => refreshOnEvent(ctx));
+    pi.on("turn_start", async (_event, ctx) => refreshOnEvent(ctx));
+    pi.on("turn_end", async (_event, ctx) => refreshOnEvent(ctx));
+    pi.on("session_tree", async (_event, ctx) => refreshOnEvent(ctx));
+    pi.on("session_compact", async (_event, ctx) => refreshOnEvent(ctx));
+    pi.on("input", async (event, ctx) => {
+        const currentConfig = config ?? loadSessionTitleConfig(ctx.cwd);
+        config = currentConfig;
+        refreshSessionUi(ctx);
+        scheduleSessionUiRefresh(ctx);
+        if (event.source === "extension")
+            return { action: "continue" };
+        const fallbackInput = fallbackTitleInputFromPrompt(event.text, event.images);
+        if (!fallbackInput)
+            return { action: "continue" };
+        const titleInput = titleGenerationInputFromPrompt(event.text, event.images) ?? fallbackInput;
+        if (event.text.trimStart().startsWith("/"))
+            return { action: "continue" };
+        const currentSessionId = ctx.sessionManager.getSessionId();
+        sessionId = currentSessionId;
+        const currentName = currentSessionName(ctx);
+        const activeForkTitleState = forkTitleState?.sessionId === currentSessionId ? forkTitleState : undefined;
+        if (!activeForkTitleState && hasExistingUserMessage(ctx)) {
+            forkTitleState = undefined;
+            return { action: "continue" };
+        }
+        if (currentName && (!activeForkTitleState || currentName !== activeForkTitleState.inheritedSessionName)) {
+            forkTitleState = undefined;
+            return { action: "continue" };
+        }
+        if (!currentConfig.enabled) {
+            applyFallbackSessionTitle(ctx, currentConfig, activeForkTitleState
+                ? buildForkTitleInput(activeForkTitleState.parentTitle, fallbackInput)
+                : fallbackInput, { force: Boolean(activeForkTitleState) });
+            forkTitleState = undefined;
+            return { action: "continue" };
+        }
+        if (!pendingGeneration || pendingGeneration.sessionId !== currentSessionId) {
+            const input = activeForkTitleState
+                ? buildForkTitleInput(activeForkTitleState.parentTitle, titleInput)
+                : titleInput;
+            const fallbackTitleInput = activeForkTitleState
+                ? buildForkTitleInput(activeForkTitleState.parentTitle, fallbackInput)
+                : fallbackInput;
+            const provisionalSessionName = fallbackSessionTitleFromInput(fallbackTitleInput, currentConfig.maxTitleChars);
+            if (provisionalSessionName && (!currentName || activeForkTitleState)) {
+                pi.setSessionName(provisionalSessionName);
+                refreshSessionUi(ctx, { force: true });
+                scheduleSessionUiRefresh(ctx);
+            }
+            pendingGeneration = {
+                sessionId: currentSessionId,
+                input: truncateInput(input, currentConfig.maxInputChars),
+                modelRefs: sessionTitleModelRefs(currentConfig),
+                modelIndex: 0,
+                attempts: 0,
+                ...(activeForkTitleState?.inheritedSessionName === undefined ? {} : { replaceSessionName: activeForkTitleState.inheritedSessionName }),
+                ...(provisionalSessionName === undefined ? {} : { provisionalSessionName }),
+            };
+            forkTitleState = undefined;
+        }
+        startTitleGeneration(ctx, currentConfig);
+        return { action: "continue" };
+    });
+}

package/dist/bundled-extensions/session-title/title-generation.d.ts

@@ -0,0 +1,26 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { SessionTitleConfig } from "./config.js";
+type SessionEntryLike = {
+    type?: string;
+    message?: {
+        role?: string;
+        content?: unknown;
+    };
+};
+type TitleModelRegistry = {
+    find(provider: string, modelId: string): Model<Api> | undefined;
+    getApiKeyAndHeaders(model: Model<Api>): Promise<{
+        ok: true;
+        apiKey?: string;
+        headers?: Record<string, string>;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+};
+export declare function firstUserMessageText(entries: readonly SessionEntryLike[]): string | undefined;
+export declare function fallbackSessionTitleFromInput(input: string, maxTitleChars: number): string | undefined;
+export declare function sanitizeSessionTitle(raw: string, maxTitleChars: number): string | undefined;
+export declare function sessionTitleModelRefs(config: SessionTitleConfig): string[];
+export declare function generateSessionTitle(input: string, modelRegistry: TitleModelRegistry, config: SessionTitleConfig, modelRef: string, signal: AbortSignal, onWarning?: (message: string) => void): Promise<string | undefined>;
+export {};