@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.512

package/dist/integrations/pi/components/upstream/theme/theme.js

@@ -0,0 +1,337 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/theme/theme.ts.
+ * Modifications: Source-synchronized theme port: retain pinned theme schema, variable/color
+ * resolution, built-in and custom loading, terminal detection, and layout defaults while constructing
+ * the public package-root Theme class.
+ * Deviations: theme-public-api-boundary, theme-owned-watcher-boundary.
+ */
+import { existsSync, readFileSync, readdirSync, watch } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir, initTheme, Theme, } from "../../../startup-public.js";
+import { getCapabilities } from "@earendil-works/pi-tui";
+import { BUILTIN_THEME_RESOURCES, isBuiltinThemeName } from "../../resources/builtin-themes.js";
+export const PINNED_PI_LAYOUT = Object.freeze({
+    editorPaddingX: 0,
+    outputPad: 1,
+    autocompleteMaxVisible: 5,
+    contentPaddingX: 1,
+    messagePaddingY: 1,
+    sectionSpacing: 1,
+    selectorMaxVisible: 10,
+});
+const FOREGROUND_COLORS = [
+    "accent", "border", "borderAccent", "borderMuted", "success", "error", "warning", "muted", "dim", "text", "scrollbarTrack", "scrollbarThumb",
+    "thinkingText", "userMessageText", "customMessageText", "customMessageLabel", "toolTitle", "toolOutput",
+    "mdHeading", "mdLink", "mdLinkUrl", "mdCode", "mdCodeBlock", "mdCodeBlockBorder", "mdQuote", "mdQuoteBorder",
+    "mdHr", "mdListBullet", "toolDiffAdded", "toolDiffRemoved", "toolDiffContext", "syntaxComment", "syntaxKeyword",
+    "syntaxFunction", "syntaxVariable", "syntaxString", "syntaxNumber", "syntaxType", "syntaxOperator", "syntaxPunctuation",
+    "thinkingOff", "thinkingMinimal", "thinkingLow", "thinkingMedium", "thinkingHigh", "thinkingXhigh", "thinkingMax", "bashMode",
+];
+const BACKGROUND_COLORS = [
+    "selectedBg", "userMessageBg", "customMessageBg", "toolPendingBg", "toolSuccessBg", "toolErrorBg",
+];
+let activeTheme;
+let activeThemeName;
+let activeThemeMode;
+let themeWatcher;
+let themeReloadTimer;
+const themeChangeListeners = new Set();
+export function ensurePiTheme() {
+    if (activeTheme)
+        return activeTheme;
+    const detected = detectPiTerminalBackgroundFromEnv();
+    applyPiTheme(detected.theme);
+    return activeTheme;
+}
+export function piTheme() {
+    return ensurePiTheme();
+}
+export function currentPiThemeName() {
+    ensurePiTheme();
+    return activeThemeName;
+}
+export function applyPiTheme(name, enableWatcher = false, mode) {
+    try {
+        const loaded = loadPiTheme(name, mode);
+        initTheme(name, false);
+        activeTheme = loaded;
+        activeThemeName = name;
+        activeThemeMode = mode;
+        if (enableWatcher)
+            startPiThemeWatcher(name);
+        notifyThemeChanged();
+        return { success: true, name };
+    }
+    catch (error) {
+        initTheme("dark", false);
+        activeTheme = loadPiTheme("dark", mode);
+        activeThemeName = "dark";
+        activeThemeMode = mode;
+        notifyThemeChanged();
+        return { success: false, name: "dark", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export function applyPiThemeInstance(theme) {
+    stopPiThemeWatcher();
+    activeTheme = theme;
+    activeThemeName = theme.name ?? "<in-memory>";
+    activeThemeMode = theme.getColorMode();
+    notifyThemeChanged();
+    return { success: true, name: activeThemeName };
+}
+export function onPiThemeChange(listener) {
+    themeChangeListeners.add(listener);
+    return () => themeChangeListeners.delete(listener);
+}
+export function stopPiThemeWatcher() {
+    if (themeReloadTimer !== undefined)
+        clearTimeout(themeReloadTimer);
+    themeReloadTimer = undefined;
+    themeWatcher?.close();
+    themeWatcher = undefined;
+}
+export function loadPiTheme(name, mode) {
+    if (!name || name.includes("/"))
+        throw new Error(`Invalid theme name: ${name}`);
+    const builtin = isBuiltinThemeName(name);
+    const path = builtin ? `owned:builtin-theme/${name}` : customThemePath(name);
+    let parsed;
+    if (builtin) {
+        parsed = BUILTIN_THEME_RESOURCES[name];
+    }
+    else {
+        const source = readFileSync(path, "utf8");
+        try {
+            parsed = JSON.parse(source);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse theme ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const themeJson = validateThemeJson(path, parsed);
+    const vars = themeJson.vars ?? {};
+    const colors = { ...themeJson.colors };
+    const thinkingMax = colors.thinkingMax ?? colors.thinkingXhigh;
+    const scrollbarThumb = colors.scrollbarThumb ?? colors.text;
+    const scrollbarTrack = colors.scrollbarTrack ?? colors.muted;
+    if (thinkingMax !== undefined)
+        colors.thinkingMax = thinkingMax;
+    if (scrollbarThumb !== undefined)
+        colors.scrollbarThumb = scrollbarThumb;
+    if (scrollbarTrack !== undefined)
+        colors.scrollbarTrack = scrollbarTrack;
+    const resolved = Object.fromEntries(Object.entries(colors).map(([key, value]) => [key, resolveVariable(value, vars)]));
+    const foreground = Object.fromEntries(FOREGROUND_COLORS.map(key => [key, requiredColor(resolved, key, path)]));
+    const backgrounds = Object.fromEntries(BACKGROUND_COLORS.map(key => [key, requiredColor(resolved, key, path)]));
+    return new Theme(foreground, backgrounds, mode ?? (getCapabilities().trueColor ? "truecolor" : "256color"), {
+        name: themeJson.name,
+        sourcePath: path,
+    });
+}
+export function getAvailablePiThemes() {
+    const available = new Map();
+    for (const name of ["dark", "light"])
+        available.set(name, `owned:builtin-theme/${name}`);
+    const customDirectory = join(getAgentDir(), "themes");
+    if (existsSync(customDirectory)) {
+        for (const file of readdirSync(customDirectory)) {
+            if (!file.endsWith(".json"))
+                continue;
+            const path = join(customDirectory, file);
+            try {
+                const parsed = validateThemeJson(path, JSON.parse(readFileSync(path, "utf8")));
+                if (!available.has(parsed.name))
+                    available.set(parsed.name, path);
+            }
+            catch { }
+        }
+    }
+    return [...available].map(([name, path]) => ({ name, path })).sort((left, right) => left.name.localeCompare(right.name));
+}
+export function parsePiAutoThemeSetting(setting) {
+    if (!setting)
+        return undefined;
+    const slashIndex = setting.indexOf("/");
+    if (slashIndex === -1 || setting.indexOf("/", slashIndex + 1) !== -1)
+        return undefined;
+    const lightTheme = setting.slice(0, slashIndex).trim();
+    const darkTheme = setting.slice(slashIndex + 1).trim();
+    return lightTheme && darkTheme ? { lightTheme, darkTheme } : undefined;
+}
+export function resolvePiThemeSetting(setting, terminalTheme) {
+    const automatic = parsePiAutoThemeSetting(setting);
+    if (automatic)
+        return terminalTheme === "light" ? automatic.lightTheme : automatic.darkTheme;
+    if (setting?.includes("/"))
+        return undefined;
+    return setting;
+}
+export function detectPiTerminalBackgroundFromEnv(environment = process.env) {
+    const parts = (environment.COLORFGBG ?? "").split(";");
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+        const background = Number.parseInt(parts[index].trim(), 10);
+        if (!Number.isInteger(background) || background < 0 || background > 255)
+            continue;
+        return {
+            theme: luminance(hexToRgb(ansi256ToHex(background))) >= 0.5 ? "light" : "dark",
+            source: "COLORFGBG",
+            detail: `background color index ${background}`,
+            confidence: "high",
+        };
+    }
+    return { theme: "dark", source: "fallback", detail: "no terminal background hint found", confidence: "low" };
+}
+export async function detectPiTerminalBackgroundTheme(ui, timeoutMs, environment = process.env) {
+    try {
+        const rgb = await ui.queryTerminalBackgroundColor({ timeoutMs });
+        if (rgb) {
+            return {
+                theme: luminance(rgb) >= 0.5 ? "light" : "dark",
+                source: "terminal background",
+                detail: `OSC 11 background rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`,
+                confidence: "high",
+            };
+        }
+    }
+    catch { }
+    return detectPiTerminalBackgroundFromEnv(environment);
+}
+export async function detectPiTerminalThemeForAuto(ui, timeoutMs, environment = process.env) {
+    let scheme;
+    try {
+        scheme = ui.queryTerminalColorScheme?.({ timeoutMs });
+    }
+    catch { }
+    const background = detectPiTerminalBackgroundTheme(ui, timeoutMs, environment);
+    try {
+        const value = await scheme;
+        if (value)
+            return value;
+    }
+    catch { }
+    return (await background).theme;
+}
+function startPiThemeWatcher(name) {
+    stopPiThemeWatcher();
+    if (isBuiltinThemeName(name))
+        return;
+    const path = customThemePath(name);
+    if (!existsSync(path))
+        return;
+    themeWatcher = watch(path, () => {
+        if (activeThemeName !== name)
+            return;
+        if (themeReloadTimer !== undefined)
+            clearTimeout(themeReloadTimer);
+        themeReloadTimer = setTimeout(() => {
+            themeReloadTimer = undefined;
+            if (activeThemeName !== name || !existsSync(path))
+                return;
+            try {
+                activeTheme = loadPiTheme(name, activeThemeMode);
+                notifyThemeChanged();
+            }
+            catch { }
+        }, 100);
+    });
+    themeWatcher.on("error", stopPiThemeWatcher);
+}
+function notifyThemeChanged() {
+    for (const listener of themeChangeListeners)
+        listener();
+}
+function customThemePath(name) {
+    return join(getAgentDir(), "themes", `${name}.json`);
+}
+function validateThemeJson(label, value) {
+    if (!isRecord(value) || typeof value.name !== "string" || !isRecord(value.colors)
+        || (value.vars !== undefined && !isRecord(value.vars))) {
+        throw new Error(`Invalid theme "${label}": expected name, colors, and optional vars objects`);
+    }
+    if (value.name.includes("/"))
+        throw new Error(`Invalid theme name "${value.name}"`);
+    for (const key of FOREGROUND_COLORS) {
+        if (key !== "thinkingMax" && key !== "scrollbarThumb" && key !== "scrollbarTrack" && value.colors[key] === undefined)
+            throw new Error(`Invalid theme "${label}": missing required color ${key}`);
+    }
+    for (const key of BACKGROUND_COLORS) {
+        if (value.colors[key] === undefined)
+            throw new Error(`Invalid theme "${label}": missing required color ${key}`);
+    }
+    const colors = {};
+    for (const [key, color] of Object.entries(value.colors)) {
+        validateColor(color, `${label}.colors.${key}`);
+        colors[key] = color;
+    }
+    const vars = {};
+    for (const [key, color] of Object.entries(value.vars ?? {})) {
+        validateColor(color, `${label}.vars.${key}`);
+        vars[key] = color;
+    }
+    return { name: value.name, colors, ...(Object.keys(vars).length === 0 ? {} : { vars }) };
+}
+function validateColor(value, label) {
+    if (typeof value === "string")
+        return;
+    if (Number.isInteger(value) && value >= 0 && value <= 255)
+        return;
+    throw new Error(`Invalid theme color: ${label}`);
+}
+function resolveVariable(value, vars, visited = new Set()) {
+    if (typeof value === "number" || value === "" || value.startsWith("#"))
+        return value;
+    if (visited.has(value))
+        throw new Error(`Circular variable reference detected: ${value}`);
+    if (!(value in vars))
+        throw new Error(`Variable reference not found: ${value}`);
+    visited.add(value);
+    return resolveVariable(vars[value], vars, visited);
+}
+function requiredColor(colors, key, label) {
+    const value = colors[key];
+    if (value === undefined)
+        throw new Error(`Invalid theme "${label}": missing required color ${key}`);
+    return value;
+}
+function luminance({ r, g, b }) {
+    const linear = (channel) => {
+        const value = channel / 255;
+        return value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+    };
+    return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+}
+function hexToRgb(hex) {
+    const value = hex.slice(1);
+    return { r: Number.parseInt(value.slice(0, 2), 16), g: Number.parseInt(value.slice(2, 4), 16), b: Number.parseInt(value.slice(4, 6), 16) };
+}
+function ansi256ToHex(index) {
+    const basic = [
+        "#000000", "#800000", "#008000", "#808000", "#000080", "#800080", "#008080", "#c0c0c0",
+        "#808080", "#ff0000", "#00ff00", "#ffff00", "#0000ff", "#ff00ff", "#00ffff", "#ffffff",
+    ];
+    if (index < 16)
+        return basic[index];
+    if (index < 232) {
+        const cube = index - 16;
+        const toHex = (value) => (value === 0 ? 0 : 55 + value * 40).toString(16).padStart(2, "0");
+        return `#${toHex(Math.floor(cube / 36))}${toHex(Math.floor((cube % 36) / 6))}${toHex(cube % 6)}`;
+    }
+    const gray = (8 + (index - 232) * 10).toString(16).padStart(2, "0");
+    return `#${gray}${gray}${gray}`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Applies the theme the reader configured, as the engine does at startup. The
+ * setting is either a theme's name or the `light/dark` pair meaning "follow the
+ * terminal", and only the pair consults the terminal's own background. An
+ * unreadable or absent setting falls back to that detection, which is what the
+ * engine does with an unset theme.
+ */
+export function applyConfiguredPiTheme(setting) {
+    const detected = detectPiTerminalBackgroundFromEnv();
+    const resolved = resolvePiThemeSetting(setting, detected.theme);
+    return applyPiTheme(resolved ?? detected.theme);
+}

package/dist/integrations/pi/engine/adapter.d.ts

@@ -0,0 +1,135 @@
+import { type AgentSession } from "../startup-public.js";
+import { type OwnedUiCommand, type OwnedUiImageAttachment, type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionReasoning, type OwnedUiPromptSuggestionRequest, type OwnedUiPromptSuggestionResult, type OwnedUiEvent, type OwnedUiSessionViewModel, type OwnedUiSnapshot } from "../../../contracts/owned-ui/index.js";
+import type { PiAuthenticationProviderOption, PiBashWorkflowResult, PiPinnedSettingsCallback, PiPinnedSettingsSnapshot, PiProjectTrustContext, PiProjectTrustUpdate, PiScopedModelsContext, PiScopedModelsRefreshResult, PiSessionResumeMetadata, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowAutocompleteCommand, PiWorkflowHost, PiWorkflowInteractionHost, PiWorkflowOption, PiWorkflowRequest, PiWorkflowResult } from "./workflows.js";
+import type { PiSettingsBridge } from "./settings-bridge.js";
+import type { PiSettingOwnerHandlers } from "./settings-bridge.js";
+import type { PiProjectTrustPreflightPrompt } from "./project-trust-preflight.js";
+import type { PiSessionForkPrompt, PiSessionSelection } from "./session-selection.js";
+import type { AgentSettingOwner } from "../../../contracts/agent-engine/index.js";
+import { type AdapterCommandResult } from "./command-dispatch.js";
+import { type OwnedPiVisualExtensionSupport } from "./extension-ui-binding.js";
+import { type OwnedPiExtensionResourceSummary, type OwnedPiResourceSummary } from "./resource-catalog.js";
+import { type PiEnginePackageUpdateProbe, type PiEngineRuntimeFactory } from "./session-runtime.js";
+import { PiWorkflowContexts } from "./workflow-contexts.js";
+export type { OwnedPiExtensionResourceSummary, OwnedPiExtensionSourceSummary, OwnedPiResourceSummary } from "./resource-catalog.js";
+export type { PiEngineRuntimeFactory, PiEngineRuntimeFactoryInput } from "./session-runtime.js";
+export type { AdapterCommandResult } from "./command-dispatch.js";
+export type { OwnedPiVisualExtensionSupport } from "./extension-ui-binding.js";
+/** Explicit flush failure when required delivery was interrupted rather than completed. */
+export declare class EngineDeliveryError extends Error {
+    constructor();
+}
+export interface PiEngineAdapterOptions {
+    readonly cwd?: string;
+    readonly agentDir?: string;
+    readonly sessionId?: string;
+    readonly sessionPath?: string;
+    readonly sessionSelection?: PiSessionSelection;
+    readonly sessionForkPrompt?: PiSessionForkPrompt;
+    readonly createRuntime?: PiEngineRuntimeFactory;
+    readonly workflowHost?: PiWorkflowHost;
+    /**
+     * Themes installed on this machine. Supplied because listing them belongs to
+     * the component adapter that owns the engine's theme unit; the grammar and the
+     * offering stay here.
+     */
+    readonly availableThemes?: () => readonly string[];
+    readonly settingsProductMode?: "bare" | "comparison";
+    readonly projectTrustPrompt?: PiProjectTrustPreflightPrompt;
+    /**
+     * Startup extension-package update probe, mirroring pinned Pi's interactive
+     * mode. Returns display names of packages with updates available.
+     */
+    readonly checkPackageUpdates?: PiEnginePackageUpdateProbe;
+}
+/** Owns the pinned Pi session lifecycle and translates its events into the neutral agent-engine contract. */
+export declare class PiEngineAdapter implements OwnedUiPromptSuggestionGeneratorPort {
+    #private;
+    constructor(options?: PiEngineAdapterOptions);
+    setWorkflowInteractionHost(interaction: PiWorkflowInteractionHost): void;
+    get sessionId(): string;
+    get sessionGeneration(): number;
+    /** Actual session replacements, excluding delivery-only invalidation of callbacks. */
+    get sessionBindingGeneration(): number;
+    get cwd(): string;
+    get agentDir(): string;
+    resolveTranscriptImage(assetId: string): OwnedUiImageAttachment | null;
+    currentSessionFile(): string | null;
+    currentSessionResumeMetadata(): PiSessionResumeMetadata | null;
+    get disposed(): boolean;
+    suggestionReasoningPolicy(): OwnedUiPromptSuggestionReasoning;
+    generate(request: OwnedUiPromptSuggestionRequest): Promise<OwnedUiPromptSuggestionResult>;
+    start(): Promise<OwnedUiSessionViewModel>;
+    onEvent(listener: (event: OwnedUiEvent) => void): () => void;
+    /** Developer-only pressure evidence; never mirrored into visible diagnostic/status arrays. */
+    deliveryDiagnostics(): {
+        pendingCommands: number;
+        overloads: number;
+        recovering: boolean;
+        reservedOutcomes: number;
+        invalidatedEvents: number;
+        pending: number;
+        bytes: number;
+        protected: number;
+        superseded: number;
+        peakNodes: number;
+        peakBytes: number;
+    };
+    flushEvents(): Promise<void>;
+    nonVisualResources(): readonly OwnedPiResourceSummary[];
+    extensionResources(): readonly OwnedPiExtensionResourceSummary[];
+    workflowAutocompleteCommands(): readonly PiWorkflowAutocompleteCommand[];
+    visualExtensionSupport(): OwnedPiVisualExtensionSupport;
+    bindExtensionUi(ui: unknown, shutdown?: () => void | Promise<void>): Promise<void>;
+    unbindExtensionUi(): Promise<void>;
+    cycleModelWorkflow(direction: "forward" | "backward"): Promise<PiWorkflowResult>;
+    pinnedModelSelectorContext(): ReturnType<PiWorkflowContexts["pinnedModelSelectorContext"]>;
+    pinnedProjectTrustContext(): PiProjectTrustContext;
+    persistProjectTrust(updates: readonly PiProjectTrustUpdate[]): void;
+    pinnedSessionSelectorContext(): PiSessionSelectorContext;
+    pinnedScopedModelsContext(): PiScopedModelsContext;
+    updateScopedModels(enabledModelIds: readonly string[] | null): void;
+    persistScopedModels(enabledModelIds: readonly string[] | null): void;
+    refreshScopedModels(signal: AbortSignal): Promise<PiScopedModelsRefreshResult>;
+    pinnedLoginOptions(authType?: "oauth" | "api_key"): readonly PiAuthenticationProviderOption[];
+    pinnedLoginMethodOptions(providerReference: string): {
+        readonly title: string;
+        readonly options: readonly PiWorkflowOption[];
+    };
+    pinnedAmbientAuthentication(selection: string): ReturnType<PiWorkflowContexts["pinnedAmbientAuthentication"]>;
+    pinnedLogoutOptions(): Promise<readonly PiAuthenticationProviderOption[]>;
+    pinnedForkOptions(): readonly PiWorkflowOption[];
+    pinnedTreeSelectorContext(): PiTreeSelectorContext;
+    /** Bind the owned UI's clipboard lifecycle without changing the comparison host. True means acknowledged delivery. */
+    bindClipboardWriter(writer: (text: string) => Promise<boolean>): () => void;
+    /** Workflow and tree copying share the active owner's write fence and delivery acknowledgment. */
+    copyWorkflowText(text: string): Promise<boolean>;
+    abortBashWorkflow(): void;
+    executeBashWorkflow(command: string, excludeFromContext: boolean): Promise<PiBashWorkflowResult>;
+    reloadBlockedResult(): PiWorkflowResult | null;
+    executeWorkflow(request: PiWorkflowRequest): Promise<PiWorkflowResult>;
+    /**
+     * The theme the engine is configured with, in the engine's own grammar: a
+     * theme's name, or a `light/dark` pair meaning "follow the terminal".
+     */
+    configuredTheme(): string | undefined;
+    /** Settings port for the live runtime, or null before the runtime is available. */
+    settingsPort(): PiSettingsBridge | null;
+    /** Which settings surface this adapter serves; hidden-in-bare effects are unbindable in bare mode. */
+    get settingsProductMode(): "bare" | "comparison";
+    bindSettingsOwner(owner: AgentSettingOwner, handlers: PiSettingOwnerHandlers): () => void;
+    pinnedSettingsSnapshot(): PiPinnedSettingsSnapshot;
+    applyPinnedSettingValue(callback: PiPinnedSettingsCallback, value: unknown): Promise<PiWorkflowResult>;
+    pinnedMessageRenderer(customType: string): unknown;
+    pinnedShortcutDescriptions(bindings: Parameters<AgentSession["extensionRunner"]["getShortcuts"]>[0]): readonly {
+        readonly key: string;
+        readonly description: string;
+    }[];
+    pinnedToolDefinition(toolName: string): unknown;
+    clearQueuedWorkflows(): readonly string[];
+    view(): OwnedUiSessionViewModel;
+    snapshot(): OwnedUiSnapshot;
+    execute(command: OwnedUiCommand): Promise<AdapterCommandResult>;
+    dispose(): Promise<void>;
+}
+export declare function createPiEngineAdapter(options?: PiEngineAdapterOptions): Promise<PiEngineAdapter>;