pi-ui-extend 0.1.1

package/dist/app/runtime.d.ts

@@ -0,0 +1,39 @@
+import { type EventBus, type AgentSessionRuntime, type LoadExtensionsResult } from "@earendil-works/pi-coding-agent";
+import type { AppOptions } from "./types.js";
+export type PiToolsSuiteInstallAction = "installed" | "already-installed" | "existing-kept" | "missing-source";
+export type PiToolsSuiteInstallResult = {
+    action: PiToolsSuiteInstallAction;
+    sourcePath: string;
+    targetPath: string;
+};
+export type PiToolsSuiteInstallOptions = {
+    agentDir?: string;
+    sourcePath?: string;
+    targetPath?: string;
+};
+export type BundledSkillsInstallAction = "installed" | "already-installed" | "missing-source";
+export type BundledSkillsInstallResult = {
+    action: BundledSkillsInstallAction;
+    sourcePath: string;
+    targetPath: string;
+};
+export type BundledSkillsInstallOptions = {
+    homeDir?: string;
+    sourcePath?: string;
+    targetPath?: string;
+};
+export declare function bundledQuestionExtensionPath(): string;
+export declare function bundledSessionTitleExtensionPath(): string;
+export declare function bundledTerminalBellExtensionPath(): string;
+export declare function piToolsSuiteExtensionSourcePath(): string;
+export declare function piToolsSuiteExtensionInstallPath(agentDir?: string): string;
+export declare function bundledSkillsSourcePath(): string;
+export declare function bundledSkillsInstallPath(homeDir?: string): string;
+export declare function ensurePiToolsSuiteExtensionInstalled(options?: PiToolsSuiteInstallOptions): Promise<PiToolsSuiteInstallResult>;
+export declare function ensureBundledSkillsInstalled(options?: BundledSkillsInstallOptions): Promise<BundledSkillsInstallResult>;
+export declare function getBundledExtensionPaths(): string[];
+export declare function prioritizeBundledQuestionExtension(base: LoadExtensionsResult, questionExtensionPath?: string): LoadExtensionsResult;
+export type CreatePixRuntimeOptions = {
+    eventBus?: EventBus;
+};
+export declare function createPixRuntime(options: AppOptions, runtimeOptions?: CreatePixRuntimeOptions): Promise<AgentSessionRuntime>;

package/dist/app/runtime.js

@@ -0,0 +1,195 @@
+import { existsSync } from "node:fs";
+import { cp, lstat, mkdir, readlink, realpath, rm, symlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { PI_FAVORITE_MODEL_REFS } from "./constants.js";
+import { parseModelRef, parseScopedModelRef } from "./model-ref.js";
+const BUNDLED_QUESTION_EXTENSION_NAME = "question";
+const PI_TOOLS_SUITE_EXTENSION_NAME = "pi-tools-suite";
+const BUNDLED_EXTENSIONS_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../..", "extensions");
+const BUNDLED_QUESTION_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, BUNDLED_QUESTION_EXTENSION_NAME);
+const BUNDLED_SESSION_TITLE_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, "session-title");
+const BUNDLED_TERMINAL_BELL_EXTENSION_DIR = resolve(BUNDLED_EXTENSIONS_DIR, "terminal-bell");
+const PI_TOOLS_SUITE_SOURCE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../..", "external", PI_TOOLS_SUITE_EXTENSION_NAME);
+const BUNDLED_SKILLS_SOURCE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../..", "skills");
+export function bundledQuestionExtensionPath() {
+    return BUNDLED_QUESTION_EXTENSION_DIR;
+}
+export function bundledSessionTitleExtensionPath() {
+    return BUNDLED_SESSION_TITLE_EXTENSION_DIR;
+}
+export function bundledTerminalBellExtensionPath() {
+    return BUNDLED_TERMINAL_BELL_EXTENSION_DIR;
+}
+export function piToolsSuiteExtensionSourcePath() {
+    return PI_TOOLS_SUITE_SOURCE_DIR;
+}
+export function piToolsSuiteExtensionInstallPath(agentDir = getAgentDir()) {
+    return join(agentDir, "extensions", PI_TOOLS_SUITE_EXTENSION_NAME);
+}
+export function bundledSkillsSourcePath() {
+    return BUNDLED_SKILLS_SOURCE_DIR;
+}
+export function bundledSkillsInstallPath(homeDir = homedir()) {
+    return join(homeDir, ".agents", "skills");
+}
+export async function ensurePiToolsSuiteExtensionInstalled(options = {}) {
+    const sourcePath = resolve(options.sourcePath ?? piToolsSuiteExtensionSourcePath());
+    const targetPath = resolve(options.targetPath ?? piToolsSuiteExtensionInstallPath(options.agentDir));
+    if (!extensionEntryExists(sourcePath)) {
+        return { action: "missing-source", sourcePath, targetPath };
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    const targetStat = await lstat(targetPath).catch(() => undefined);
+    if (!targetStat) {
+        await symlink(sourcePath, targetPath, extensionSymlinkType());
+        return { action: "installed", sourcePath, targetPath };
+    }
+    if (targetStat.isSymbolicLink()) {
+        const currentTarget = resolve(dirname(targetPath), await readlink(targetPath));
+        if (await pathsReferToSameEntry(currentTarget, sourcePath)) {
+            return { action: "already-installed", sourcePath, targetPath };
+        }
+        await rm(targetPath, { force: true });
+        await symlink(sourcePath, targetPath, extensionSymlinkType());
+        return { action: "installed", sourcePath, targetPath };
+    }
+    if (await pathsReferToSameEntry(targetPath, sourcePath)) {
+        return { action: "already-installed", sourcePath, targetPath };
+    }
+    return { action: "existing-kept", sourcePath, targetPath };
+}
+export async function ensureBundledSkillsInstalled(options = {}) {
+    const sourcePath = resolve(options.sourcePath ?? bundledSkillsSourcePath());
+    const targetPath = resolve(options.targetPath ?? bundledSkillsInstallPath(options.homeDir));
+    const sourceStat = await lstat(sourcePath).catch(() => undefined);
+    if (!sourceStat?.isDirectory()) {
+        return { action: "missing-source", sourcePath, targetPath };
+    }
+    if (await pathsReferToSameEntry(sourcePath, targetPath)) {
+        return { action: "already-installed", sourcePath, targetPath };
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    await cp(sourcePath, targetPath, { recursive: true, force: true });
+    return { action: "installed", sourcePath, targetPath };
+}
+export function getBundledExtensionPaths() {
+    return [
+        bundledQuestionExtensionPath(),
+        bundledSessionTitleExtensionPath(),
+        bundledTerminalBellExtensionPath(),
+    ].filter(extensionEntryExists);
+}
+export function prioritizeBundledQuestionExtension(base, questionExtensionPath = bundledQuestionExtensionPath()) {
+    const bundledQuestionExtensions = base.extensions.filter((extension) => isBundledQuestionExtension(extension, questionExtensionPath));
+    if (bundledQuestionExtensions.length === 0)
+        return base;
+    const bundledExtensionPaths = new Set(bundledQuestionExtensions.map((extension) => extension.path));
+    return {
+        ...base,
+        extensions: [
+            ...bundledQuestionExtensions,
+            ...base.extensions.filter((extension) => !bundledExtensionPaths.has(extension.path)),
+        ],
+        errors: base.errors.filter((error) => !isBundledQuestionConflict(error, bundledExtensionPaths)),
+    };
+}
+function extensionEntryExists(extensionPath) {
+    return existsSync(join(extensionPath, "index.ts")) || existsSync(join(extensionPath, "index.js"));
+}
+function extensionSymlinkType() {
+    return process.platform === "win32" ? "junction" : "dir";
+}
+async function pathsReferToSameEntry(leftPath, rightPath) {
+    try {
+        const [leftRealPath, rightRealPath] = await Promise.all([realpath(leftPath), realpath(rightPath)]);
+        return normalizePathForCompare(leftRealPath) === normalizePathForCompare(rightRealPath);
+    }
+    catch {
+        return normalizePathForCompare(resolve(leftPath)) === normalizePathForCompare(resolve(rightPath));
+    }
+}
+function normalizePathForCompare(pathValue) {
+    const normalized = resolve(pathValue);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isBundledQuestionExtension(extension, questionExtensionPath) {
+    return extension.tools.has(BUNDLED_QUESTION_EXTENSION_NAME) && pathIsInside(extension.resolvedPath, questionExtensionPath);
+}
+function pathIsInside(candidatePath, parentPath) {
+    const relativePath = relative(resolve(parentPath), resolve(candidatePath));
+    return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+function isBundledQuestionConflict(error, bundledExtensionPaths) {
+    if (!error.error.startsWith(`Tool "${BUNDLED_QUESTION_EXTENSION_NAME}" conflicts with `))
+        return false;
+    for (const bundledExtensionPath of bundledExtensionPaths) {
+        if (error.path === bundledExtensionPath || error.error.endsWith(bundledExtensionPath))
+            return true;
+    }
+    return false;
+}
+export async function createPixRuntime(options, runtimeOptions = {}) {
+    const parsedModel = options.modelRef ? parseModelRef(options.modelRef) : undefined;
+    const agentDir = getAgentDir();
+    const createRuntime = async ({ cwd, sessionManager, sessionStartEvent }) => {
+        await ensureBundledSkillsInstalled();
+        await ensurePiToolsSuiteExtensionInstalled({ agentDir });
+        const bundledExtensionPaths = getBundledExtensionPaths();
+        const services = await createAgentSessionServices({
+            cwd,
+            agentDir,
+            resourceLoaderOptions: {
+                ...(runtimeOptions.eventBus === undefined ? {} : { eventBus: runtimeOptions.eventBus }),
+                ...(bundledExtensionPaths.length === 0 ? {} : {
+                    additionalExtensionPaths: bundledExtensionPaths,
+                    extensionsOverride: prioritizeBundledQuestionExtension,
+                }),
+            },
+        });
+        services.modelRegistry.refresh();
+        const model = parsedModel ? services.modelRegistry.find(parsedModel.provider, parsedModel.modelId) : undefined;
+        if (parsedModel && !model) {
+            throw new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
+        }
+        const enabledModelRefs = services.settingsManager.getEnabledModels();
+        const favoriteModelRefs = enabledModelRefs && enabledModelRefs.length > 0 ? enabledModelRefs : PI_FAVORITE_MODEL_REFS;
+        const scopedModels = favoriteModelRefs.flatMap((modelRef) => {
+            const scoped = parseScopedModelRef(modelRef);
+            if (!scoped)
+                return [];
+            const scopedModel = services.modelRegistry.find(scoped.provider, scoped.modelId);
+            if (!scopedModel)
+                return [];
+            return [
+                {
+                    model: scopedModel,
+                    ...(scoped.thinkingLevel === undefined ? {} : { thinkingLevel: scoped.thinkingLevel }),
+                },
+            ];
+        });
+        return {
+            ...(await createAgentSessionFromServices({
+                services,
+                sessionManager,
+                ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
+                ...(model === undefined ? {} : { model }),
+                ...(parsedModel?.thinkingLevel === undefined ? {} : { thinkingLevel: parsedModel.thinkingLevel }),
+                ...(scopedModels.length === 0 ? {} : { scopedModels }),
+            })),
+            services,
+            diagnostics: services.diagnostics,
+        };
+    };
+    return await createAgentSessionRuntime(createRuntime, {
+        cwd: options.cwd,
+        agentDir,
+        sessionManager: options.noSession
+            ? SessionManager.inMemory(options.cwd)
+            : options.sessionPath
+                ? SessionManager.open(options.sessionPath, undefined, options.cwd)
+                : SessionManager.create(options.cwd),
+    });
+}

package/dist/app/screen-selection.d.ts

@@ -0,0 +1,6 @@
+import type { ScreenPoint } from "./types.js";
+export declare function samePoint(left: ScreenPoint, right: ScreenPoint): boolean;
+export declare function orderedSelection(anchor: ScreenPoint, current: ScreenPoint): {
+    start: ScreenPoint;
+    end: ScreenPoint;
+};

package/dist/app/screen-selection.js

@@ -0,0 +1,9 @@
+export function samePoint(left, right) {
+    return left.x === right.x && left.y === right.y;
+}
+export function orderedSelection(anchor, current) {
+    if (anchor.y < current.y || (anchor.y === current.y && anchor.x <= current.x)) {
+        return { start: anchor, end: current };
+    }
+    return { start: current, end: anchor };
+}

package/dist/app/screen-styler.d.ts

@@ -0,0 +1,34 @@
+import { type Theme } from "../theme.js";
+import type { MouseSelection, RenderedLine, StyledSegment } from "./types.js";
+export type ScreenStylerHost = {
+    readonly theme: Theme;
+    readonly cwd?: string;
+    readonly mouseSelection: MouseSelection | undefined;
+};
+export declare class ScreenStyler {
+    private readonly host;
+    constructor(host: ScreenStylerHost);
+    styleBaseLine(row: number, line: RenderedLine | undefined, width: number): string;
+    styleLineSegments(row: number, text: string, width: number, baseOptions: {
+        foreground?: string;
+        background?: string;
+        bold?: boolean;
+        underline?: boolean;
+    }, segments: readonly StyledSegment[]): string;
+    styleLine(row: number, text: string, width: number, options: {
+        foreground?: string;
+        background?: string;
+        bold?: boolean;
+        underline?: boolean;
+    }): string;
+    styleInputLine(row: number, text: string, tagSpans: readonly {
+        start: number;
+        end: number;
+    }[] | undefined, width: number, tagColor: string, frameColor?: string): string;
+    private styleAnsiLine;
+    selectionRangeForRow(row: number, width: number): {
+        startIndex: number;
+        endIndex: number;
+    } | undefined;
+    private baseLineForeground;
+}

package/dist/app/screen-styler.js

@@ -0,0 +1,168 @@
+import { ANSI_RESET, colorize } from "../theme.js";
+import { renderMarkdownLine } from "../markdown-format.js";
+import { syntaxHighlightSegmentsForLine } from "../syntax-highlight.js";
+import { padOrTrimPlain } from "./render-text.js";
+import { orderedSelection } from "./screen-selection.js";
+export class ScreenStyler {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    styleBaseLine(row, line, width) {
+        const foreground = line?.colorOverride ?? this.baseLineForeground(line?.variant);
+        const options = {
+            foreground,
+            ...(line?.backgroundOverride === undefined ? {} : { background: line.backgroundOverride }),
+        };
+        const colors = this.host.theme.colors;
+        const markdownLine = line?.syntaxHighlight?.language === "markdown"
+            ? renderMarkdownDisplayLine(line.text, width, line.syntaxHighlight.start)
+            : undefined;
+        const text = markdownLine?.text ?? line?.text ?? "";
+        if (line?.syntaxHighlight && !this.selectionRangeForRow(row, width)) {
+            const syntaxHighlight = markdownLine ? { ...line.syntaxHighlight, start: Math.min(line.syntaxHighlight.start, markdownLine.text.length) } : line.syntaxHighlight;
+            const segments = [
+                ...syntaxHighlightSegmentsForLine(text, syntaxHighlight, colors),
+                ...(markdownLine?.segments ?? []),
+                ...(line.segments ?? []),
+            ];
+            if (segments.length > 0)
+                return this.styleLineSegments(row, text, width, options, segments);
+        }
+        if (line?.segments && line.segments.length > 0) {
+            return this.styleLineSegments(row, text, width, options, line.segments);
+        }
+        return this.styleLine(row, text, width, options);
+    }
+    styleLineSegments(row, text, width, baseOptions, segments) {
+        if (this.selectionRangeForRow(row, width))
+            return this.styleLine(row, text, width, baseOptions);
+        const plain = padOrTrimPlain(text, width);
+        const chunks = [];
+        let offset = 0;
+        const endOffset = plain.length;
+        for (const segment of [...segments].sort((a, b) => a.start - b.start)) {
+            const start = Math.max(offset, Math.min(endOffset, segment.start));
+            const end = Math.max(start, Math.min(endOffset, segment.end));
+            if (start > offset)
+                chunks.push(colorize(plain.slice(offset, start), baseOptions));
+            if (end > start)
+                chunks.push(colorize(plain.slice(start, end), { ...baseOptions, ...segment }));
+            offset = end;
+        }
+        if (offset < endOffset)
+            chunks.push(colorize(plain.slice(offset, endOffset), baseOptions));
+        return chunks.join("");
+    }
+    styleLine(row, text, width, options) {
+        const plain = padOrTrimPlain(text, width);
+        const range = this.selectionRangeForRow(row, width);
+        if (!range)
+            return colorize(plain, options);
+        const before = plain.slice(0, range.startIndex);
+        const selected = plain.slice(range.startIndex, range.endIndex);
+        const after = plain.slice(range.endIndex);
+        return [
+            colorize(before, options),
+            colorize(selected, {
+                foreground: this.host.theme.colors.selectionForeground,
+                background: this.host.theme.colors.selectionBackground,
+                bold: true,
+            }),
+            colorize(after, options),
+        ].join("");
+    }
+    styleInputLine(row, text, tagSpans, width, tagColor, frameColor) {
+        const colors = this.host.theme.colors;
+        const baseOptions = { foreground: colors.inputForeground };
+        if (this.selectionRangeForRow(row, width))
+            return this.styleLine(row, text, width, baseOptions);
+        const plain = padOrTrimPlain(text, width);
+        const frameSpans = inputFrameSpans(plain, width, frameColor);
+        if ((!tagSpans || tagSpans.length === 0) && frameSpans.length === 0) {
+            return hasAnsi(plain) ? this.styleAnsiLine(plain, baseOptions) : colorize(plain, baseOptions);
+        }
+        const chunks = [];
+        let offset = 0;
+        const endOffset = plain.length;
+        const spans = [
+            ...frameSpans,
+            ...(tagSpans ?? []).map((span) => ({ ...span, foreground: tagColor, bold: true })),
+        ].sort((a, b) => a.start - b.start || a.end - b.end);
+        for (const span of spans) {
+            const start = Math.max(offset, Math.min(endOffset, span.start));
+            const end = Math.max(start, Math.min(endOffset, span.end));
+            if (start > offset)
+                chunks.push(colorize(plain.slice(offset, start), baseOptions));
+            if (end > start)
+                chunks.push(colorize(plain.slice(start, end), { ...baseOptions, ...span }));
+            offset = end;
+        }
+        if (offset < endOffset)
+            chunks.push(colorize(plain.slice(offset), baseOptions));
+        return chunks.join("");
+    }
+    styleAnsiLine(text, options) {
+        const prefix = colorize("", options).replace(new RegExp(`${escapeRegExp(ANSI_RESET)}$`), "");
+        if (!prefix)
+            return text;
+        return `${prefix}${text.replaceAll(ANSI_RESET, `${ANSI_RESET}${prefix}`)}${ANSI_RESET}`;
+    }
+    selectionRangeForRow(row, width) {
+        if (!this.host.mouseSelection)
+            return undefined;
+        const anchor = this.host.mouseSelection.screenAnchor ?? this.host.mouseSelection.anchor;
+        const current = this.host.mouseSelection.screenCurrent ?? this.host.mouseSelection.current;
+        const { start, end } = orderedSelection(anchor, current);
+        if (row < start.y || row > end.y)
+            return undefined;
+        const startColumn = row === start.y ? start.x : 1;
+        const endColumn = row === end.y ? end.x : width + 1;
+        const startIndex = Math.max(0, Math.min(width, startColumn - 1));
+        const endIndex = Math.max(startIndex, Math.min(width, endColumn - 1));
+        return endIndex > startIndex ? { startIndex, endIndex } : undefined;
+    }
+    baseLineForeground(variant) {
+        const colors = this.host.theme.colors;
+        switch (variant) {
+            case "accent":
+                return colors.accent;
+            case "error":
+                return colors.error;
+            case "muted":
+                return colors.muted;
+            case "normal":
+            case undefined:
+                return colors.foreground;
+        }
+    }
+}
+function hasAnsi(text) {
+    return text.includes("\x1b[");
+}
+function renderMarkdownDisplayLine(text, width, start) {
+    if (width > 1 && text[0] === "│" && text[width - 1] === "│" && start > 0) {
+        const innerWidth = Math.max(0, width - 2);
+        const inner = renderMarkdownLine(text.slice(1, width - 1), start - 1);
+        return {
+            text: `│${padOrTrimPlain(inner.text, innerWidth)}│`,
+            segments: inner.segments.map((segment) => ({ ...segment, start: segment.start + 1, end: segment.end + 1 })),
+        };
+    }
+    const line = renderMarkdownLine(text, start);
+    return { text: line.text, segments: [...line.segments] };
+}
+function inputFrameSpans(text, width, frameColor) {
+    if (!frameColor || width <= 0 || text.length === 0)
+        return [];
+    const spans = [];
+    if (text[0] === "│")
+        spans.push({ start: 0, end: 1, foreground: frameColor });
+    if (width > 1 && text[Math.min(width, text.length) - 1] === "│") {
+        spans.push({ start: width - 1, end: width, foreground: frameColor });
+    }
+    return spans;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/app/scroll-controller.d.ts

@@ -0,0 +1,51 @@
+import type { ConversationViewport } from "./conversation-viewport.js";
+import type { EditorLayoutRenderer } from "./editor-layout-renderer.js";
+import type { RenderedLine } from "./types.js";
+export type AppScrollMetrics = {
+    bodyHeight: number;
+    viewportColumns: number;
+    conversationLineCount: number;
+    maxScroll: number;
+    start: number;
+};
+export type AppScrollBarMetrics = {
+    thumbStartRow: number;
+    thumbEndRow: number;
+};
+export type ConversationTextScrollTarget = {
+    entryId?: string;
+    needles: readonly string[];
+};
+export type AppScrollControllerHost = {
+    conversationViewport(): ConversationViewport;
+    editorLayoutRenderer(): EditorLayoutRenderer;
+    terminalColumns(): number;
+    terminalRows(): number;
+    tabPanelRows(terminalRows: number): number;
+    render(): void;
+};
+export declare class AppScrollController {
+    private readonly host;
+    private scrollFromBottom;
+    private detachedScrollStart;
+    constructor(host: AppScrollControllerHost);
+    reset(): void;
+    conversationView(columns: number, bodyHeight: number): {
+        lines: RenderedLine[];
+        metrics: AppScrollMetrics;
+    };
+    visibleConversationLines(columns: number, bodyHeight: number): RenderedLine[];
+    scrollMetrics(columns: number, bodyHeight: number): AppScrollMetrics;
+    scrollBarForMetrics(metrics: AppScrollMetrics): AppScrollBarMetrics | undefined;
+    scrollBarMetrics(columns: number, bodyHeight: number): AppScrollBarMetrics | undefined;
+    scrollByPage(direction: -1 | 1): void;
+    scrollByLines(delta: number, options?: {
+        render?: boolean;
+    }): boolean;
+    scrollToScrollbarPosition(bodyRow: number): boolean;
+    scrollToConversationEntry(entryId: string): boolean;
+    scrollToConversationText(target: ConversationTextScrollTarget): boolean;
+    private scrollToStart;
+    private setScrollStart;
+    private viewportColumns;
+}