@timurproko/a1 0.1.0 → 0.1.1-dev.10

package/dist/src/foundation/pi-engine-adapter/conformance.js

@@ -3,6 +3,29 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, ModelRuntime, SessionManager, VERSION, } from "@earendil-works/pi-coding-agent";
 import { OWNED_UI_CONTRACT_VERSION } from "../owned-ui-contracts/index.js";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+export const REQUIRED_PI_CAPABILITY_OPERATIONS = Object.freeze({
+    "public-exports": ["services.create", "session.create", "runtime.create"],
+    "session-lifecycle": ["session.new", "session.resume", "session.rebind", "session.dispose"],
+    "commands-events": ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"],
+    "models-authentication": ["models.list", "models.refresh", "auth.status", "auth.login", "auth.logout", "auth.cancel"],
+    settings: ["settings.read", "settings.write", "settings.flush"],
+    "resources-extensions": ["resources.discover", "extensions.bind", "extensions.reload", "renderers.invoke"],
+    workflows: ["workflow.route", "workflow.validate", "workflow.diagnostics"],
+    disposal: ["subscription.dispose", "session.dispose", "services.cleanup"],
+});
+export class PiCapabilityCompatibilityError extends Error {
+    packageVersion;
+    capability;
+    operation;
+    constructor(packageVersion, capability, operation, detail) {
+        super(`Pi ${packageVersion} capability ${capability} operation ${operation} is incompatible: ${detail}`);
+        this.packageVersion = packageVersion;
+        this.capability = capability;
+        this.operation = operation;
+        this.name = "PiCapabilityCompatibilityError";
+    }
+}
 export class PiUpgradeConformanceError extends Error {
     stage;
     constructor(stage, cause) {
@@ -24,7 +47,7 @@ export async function runPiUpgradeConformance() {
     catch (error) {
         throw new PiUpgradeConformanceError("exports", error);
     }
-    const root = await mkdtemp(join(tmpdir(), "addone-pi-conformance-"));
+    const root = await mkdtemp(join(tmpdir(), `${PRODUCT_IDENTITY.filesystem.temporaryPrefix}pi-conformance-`));
     try {
         let services;
         try {
@@ -52,34 +75,56 @@ export async function runPiUpgradeConformance() {
             });
             const session = created.session;
             sessionId = session.sessionId;
-            for (const method of [
-                session.prompt,
-                session.abort,
-                session.compact,
-                session.setModel,
-                session.setThinkingLevel,
-                session.subscribe,
-                session.dispose,
-            ]) {
-                if (typeof method !== "function")
-                    throw new Error("session command surface is incomplete");
-            }
+            requireMethods(session, "session commands", ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"]);
+            requireMethods(services.modelRuntime, "models/authentication", ["getModels", "getModel", "checkAuth", "login", "logout", "refresh"]);
+            requireMethods(services.settingsManager, "settings", ["getGlobalSettings", "getProjectSettings", "flush"]);
+            requireMethods(services.resourceLoader, "resources/extensions", ["getExtensions", "getSkills", "getPrompts", "getThemes", "reload"]);
+            const unsubscribe = session.subscribe(() => undefined);
+            unsubscribe();
             session.dispose();
         }
         catch (error) {
             throw new PiUpgradeConformanceError("session", error);
         }
+        const commandSurface = ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
+        const capabilities = Object.entries(REQUIRED_PI_CAPABILITY_OPERATIONS)
+            .map(([capabilityName, operations]) => capability(capabilityName, operations));
+        validatePiCapabilityResults(VERSION, capabilities);
         return {
+            schema: "pi-engine-conformance-v1",
             packageName: "@earendil-works/pi-coding-agent",
             packageVersion: VERSION,
             ownedUiContractVersion: OWNED_UI_CONTRACT_VERSION,
             serviceDiagnostics: services.diagnostics.length,
             sessionId,
-            commandSurface: ["prompt", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"],
+            commandSurface,
+            capabilities,
         };
     }
     finally {
         await rm(root, { recursive: true, force: true });
     }
 }
-//# sourceMappingURL=conformance.js.map
+function requireMethods(target, capabilityName, operations) {
+    const surface = target;
+    for (const operation of operations) {
+        if (typeof surface[operation] !== "function")
+            throw new Error(`${capabilityName}.${operation} is unavailable`);
+    }
+}
+function capability(capabilityName, operations) {
+    return { capability: capabilityName, operations, passed: true };
+}
+export function validatePiCapabilityResults(packageVersion, results) {
+    for (const [capabilityName, requiredOperations] of Object.entries(REQUIRED_PI_CAPABILITY_OPERATIONS)) {
+        const result = results.find(candidate => candidate.capability === capabilityName);
+        if (!result)
+            throw new PiCapabilityCompatibilityError(packageVersion, capabilityName, requiredOperations[0], "capability result is missing");
+        if (!result.passed)
+            throw new PiCapabilityCompatibilityError(packageVersion, capabilityName, requiredOperations[0], "capability reported failure");
+        for (const operation of requiredOperations) {
+            if (!result.operations.includes(operation))
+                throw new PiCapabilityCompatibilityError(packageVersion, capabilityName, operation, "required operation is missing");
+        }
+    }
+}

package/dist/src/foundation/pi-engine-adapter/index.d.ts

@@ -1,4 +1,9 @@
 export * from "./adapter.js";
 export * from "./conformance.js";
+export * from "./runtime-integration.js";
+export * from "./session-integration.js";
+export * from "./model-auth-integration.js";
+export * from "./settings-integration.js";
+export * from "./resource-extension-integration.js";
+export * from "./workflow-controllers.js";
 export * from "./workflows.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/foundation/pi-engine-adapter/index.js

@@ -1,4 +1,9 @@
 export * from "./adapter.js";
 export * from "./conformance.js";
+export * from "./runtime-integration.js";
+export * from "./session-integration.js";
+export * from "./model-auth-integration.js";
+export * from "./settings-integration.js";
+export * from "./resource-extension-integration.js";
+export * from "./workflow-controllers.js";
 export * from "./workflows.js";
-//# sourceMappingURL=index.js.map

package/dist/src/foundation/pi-engine-adapter/model-auth-integration.d.ts

@@ -0,0 +1,30 @@
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import type { AgentAuthenticationPort, AgentModelDescriptor, AgentModelPort } from "../agent-engine-contracts/index.js";
+export type PiDocumentedModelRuntime = Pick<ModelRuntime, "getAvailableSnapshot" | "getModel" | "getProvider" | "hasConfiguredAuth" | "refresh" | "logout">;
+export interface PiModelAuthenticationOptions {
+    readonly runtime: PiDocumentedModelRuntime;
+    readonly currentModel: () => AgentModelDescriptor | null;
+    readonly selectModel: (model: ReturnType<PiDocumentedModelRuntime["getModel"]> extends infer T ? Exclude<T, undefined> : never) => Promise<void>;
+    readonly login: (providerId: string, signal: AbortSignal) => Promise<void>;
+    readonly timeoutMs?: number;
+    readonly scopedModelIds?: () => readonly string[] | undefined;
+}
+export declare class PiModelAuthenticationIntegration implements AgentModelPort, AgentAuthenticationPort {
+    #private;
+    private readonly options;
+    readonly capabilities: {
+        selection: boolean;
+        refresh: boolean;
+        scopedCatalog: boolean;
+        login: boolean;
+        logout: boolean;
+    };
+    constructor(options: PiModelAuthenticationOptions);
+    listModels(): Promise<readonly AgentModelDescriptor[]>;
+    currentModel(): Promise<AgentModelDescriptor | null>;
+    selectModel(providerId: string, modelId: string): Promise<void>;
+    refreshModels(): Promise<void>;
+    status(providerId: string): Promise<"authenticated" | "unauthenticated" | "unavailable">;
+    login(providerId: string, signal?: AbortSignal): Promise<void>;
+    logout(providerId: string): Promise<void>;
+}

package/dist/src/foundation/pi-engine-adapter/model-auth-integration.js

@@ -0,0 +1,61 @@
+export class PiModelAuthenticationIntegration {
+    options;
+    capabilities = { selection: true, refresh: true, scopedCatalog: true, login: true, logout: true };
+    #timeoutMs;
+    constructor(options) {
+        this.options = options;
+        this.#timeoutMs = options.timeoutMs ?? 30_000;
+    }
+    async listModels() {
+        const scope = this.options.scopedModelIds?.();
+        const selected = scope ? new Set(scope) : null;
+        return this.options.runtime.getAvailableSnapshot()
+            .filter(model => !selected || selected.has(`${model.provider}/${model.id}`))
+            .map(model => ({
+            providerId: model.provider,
+            modelId: model.id,
+            displayName: model.name,
+            contextWindow: model.contextWindow,
+            thinkingLevels: [],
+        }));
+    }
+    async currentModel() { return this.options.currentModel(); }
+    async selectModel(providerId, modelId) {
+        const model = this.options.runtime.getModel(providerId, modelId);
+        if (!model)
+            throw new Error(`model is unavailable: ${providerId}/${modelId}`);
+        await this.options.selectModel(model);
+    }
+    async refreshModels() {
+        await this.options.runtime.refresh();
+    }
+    async status(providerId) {
+        return this.options.runtime.getProvider(providerId) === undefined
+            ? "unavailable"
+            : this.options.runtime.hasConfiguredAuth(providerId) ? "authenticated" : "unauthenticated";
+    }
+    async login(providerId, signal) {
+        await boundedOperation(inner => this.options.login(providerId, inner), this.#timeoutMs, signal);
+    }
+    async logout(providerId) {
+        await boundedOperation(signal => this.options.runtime.logout(providerId, { signal }), this.#timeoutMs);
+    }
+}
+async function boundedOperation(operation, timeoutMs, outer) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(outer?.reason);
+    outer?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(() => controller.abort(new Error(`model/authentication operation timed out after ${timeoutMs}ms`)), timeoutMs);
+    try {
+        if (outer?.aborted)
+            abort();
+        await Promise.race([
+            operation(controller.signal),
+            new Promise((_, reject) => controller.signal.addEventListener("abort", () => reject(controller.signal.reason ?? new Error("model/authentication operation cancelled")), { once: true })),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+        outer?.removeEventListener("abort", abort);
+    }
+}

package/dist/src/foundation/pi-engine-adapter/pi-settings-metadata.json

@@ -0,0 +1,374 @@
+{
+    "presented": [
+        "autoCompact",
+        "showImages",
+        "imageWidthCells",
+        "autoResizeImages",
+        "blockImages",
+        "enableSkillCommands",
+        "showHardwareCursor",
+        "editorPaddingX",
+        "outputPad",
+        "autocompleteMaxVisible",
+        "clearOnShrink",
+        "showTerminalProgress",
+        "steeringMode",
+        "followUpMode",
+        "transport",
+        "httpIdleTimeoutMs",
+        "hideThinkingBlock",
+        "mermaidRenderingMode",
+        "showCacheMissNotices",
+        "collapseChangelog",
+        "quietStartup",
+        "enableInstallTelemetry",
+        "defaultProjectTrust",
+        "doubleEscapeAction",
+        "treeFilterMode",
+        "warnings",
+        "thinkingLevel",
+        "tuiMode",
+        "fullscreenExitOutput",
+        "fullscreenScrollbar",
+        "theme"
+    ],
+    "order": [
+        "autoCompact",
+        "showImages",
+        "imageWidthCells",
+        "autoResizeImages",
+        "blockImages",
+        "enableSkillCommands",
+        "showHardwareCursor",
+        "editorPaddingX",
+        "outputPad",
+        "autocompleteMaxVisible",
+        "clearOnShrink",
+        "showTerminalProgress",
+        "steeringMode",
+        "followUpMode",
+        "transport",
+        "httpIdleTimeoutMs",
+        "hideThinkingBlock",
+        "mermaidRenderingMode",
+        "showCacheMissNotices",
+        "collapseChangelog",
+        "quietStartup",
+        "enableInstallTelemetry",
+        "defaultProjectTrust",
+        "doubleEscapeAction",
+        "treeFilterMode",
+        "warnings",
+        "thinkingLevel",
+        "tuiMode",
+        "fullscreenExitOutput",
+        "fullscreenScrollbar",
+        "theme"
+    ],
+    "settings": {
+        "autoCompact": {
+            "label": "Auto-compact",
+            "description": "Automatically compact context when it gets too large",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "showImages": {
+            "label": "Show images",
+            "description": "Render images inline in terminal",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "imageWidthCells": {
+            "label": "Image width",
+            "description": "Preferred inline image width in terminal cells",
+            "opensDialog": false,
+            "values": [
+                "60",
+                "80",
+                "120"
+            ]
+        },
+        "autoResizeImages": {
+            "label": "Auto-resize images",
+            "description": "Resize large images to 2000x2000 max for better model compatibility",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "blockImages": {
+            "label": "Block images",
+            "description": "Prevent images from being sent to LLM providers",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "enableSkillCommands": {
+            "label": "Skill commands",
+            "description": "Register skills as /skill:name commands",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "showHardwareCursor": {
+            "label": "Show hardware cursor",
+            "description": "Show the terminal cursor while still positioning it for IME support",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "editorPaddingX": {
+            "label": "Editor padding",
+            "description": "Horizontal padding for input editor (0-3)",
+            "opensDialog": false,
+            "values": [
+                "0",
+                "1",
+                "2",
+                "3"
+            ]
+        },
+        "outputPad": {
+            "label": "Output padding",
+            "description": "Horizontal padding for user messages, assistant messages, and thinking",
+            "opensDialog": false,
+            "values": [
+                "0",
+                "1"
+            ]
+        },
+        "autocompleteMaxVisible": {
+            "label": "Autocomplete max items",
+            "description": "Max visible items in autocomplete dropdown (3-20)",
+            "opensDialog": false,
+            "values": [
+                "3",
+                "5",
+                "7",
+                "10",
+                "15",
+                "20"
+            ]
+        },
+        "clearOnShrink": {
+            "label": "Clear on shrink",
+            "description": "Clear empty rows when content shrinks (may cause flicker)",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "showTerminalProgress": {
+            "label": "Terminal progress",
+            "description": "Show OSC 9;4 progress indicators in the terminal tab bar",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "steeringMode": {
+            "label": "Steering mode",
+            "description": "Enter while streaming queues steering messages. 'one-at-a-time': deliver one, wait for response. 'all': deliver all at once.",
+            "opensDialog": false,
+            "values": [
+                "one-at-a-time",
+                "all"
+            ]
+        },
+        "followUpMode": {
+            "label": "Follow-up mode",
+            "description": "",
+            "opensDialog": false,
+            "values": [
+                "one-at-a-time",
+                "all"
+            ]
+        },
+        "transport": {
+            "label": "Transport",
+            "description": "Preferred transport for providers that support multiple transports",
+            "opensDialog": false,
+            "values": [
+                "sse",
+                "websocket",
+                "websocket-cached",
+                "auto"
+            ]
+        },
+        "httpIdleTimeoutMs": {
+            "label": "HTTP idle timeout",
+            "description": "Maximum idle gap while waiting for HTTP headers or body chunks. Disable for local models that pause longer than five minutes.",
+            "opensDialog": false
+        },
+        "hideThinkingBlock": {
+            "label": "Hide thinking",
+            "description": "Hide thinking blocks in assistant responses",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "mermaidRenderingMode": {
+            "label": "Mermaid diagrams",
+            "description": "Render Mermaid code blocks as Unicode diagrams",
+            "opensDialog": false,
+            "values": [
+                "off",
+                "final",
+                "streaming"
+            ]
+        },
+        "showCacheMissNotices": {
+            "label": "Cache miss notices",
+            "description": "Show transcript notices for significant prompt-cache misses",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "collapseChangelog": {
+            "label": "Collapse changelog",
+            "description": "Show condensed changelog after updates",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "quietStartup": {
+            "label": "Quiet startup",
+            "description": "Disable verbose printing at startup",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "enableInstallTelemetry": {
+            "label": "Install telemetry",
+            "description": "Send an anonymous version/update ping after changelog-detected updates",
+            "opensDialog": false,
+            "values": [
+                "true",
+                "false"
+            ]
+        },
+        "defaultProjectTrust": {
+            "label": "Default project trust",
+            "description": "Fallback behavior when no extension or saved trust decision decides project trust",
+            "opensDialog": false,
+            "values": [
+                "ask",
+                "always",
+                "never"
+            ]
+        },
+        "doubleEscapeAction": {
+            "label": "Double-escape action",
+            "description": "Action when pressing Escape twice with empty editor",
+            "opensDialog": false,
+            "values": [
+                "tree",
+                "fork",
+                "none"
+            ]
+        },
+        "treeFilterMode": {
+            "label": "Tree filter mode",
+            "description": "Default filter when opening /tree",
+            "opensDialog": false,
+            "values": [
+                "default",
+                "no-tools",
+                "user-only",
+                "labeled-only",
+                "all"
+            ]
+        },
+        "warnings": {
+            "label": "Warnings",
+            "description": "Enable or disable individual warnings",
+            "opensDialog": true,
+            "literalValue": "configure"
+        },
+        "thinkingLevel": {
+            "label": "Thinking level",
+            "description": "Reasoning depth for thinking-capable models",
+            "opensDialog": true
+        },
+        "tuiMode": {
+            "label": "TUI mode",
+            "description": "Interface layout; fullscreen mode is experimental",
+            "opensDialog": false,
+            "values": [
+                "regular",
+                "fullscreen"
+            ]
+        },
+        "fullscreenExitOutput": {
+            "label": "Fullscreen exit output",
+            "description": "Print the transcript or only a session resume hint when exiting fullscreen mode",
+            "opensDialog": false,
+            "values": [
+                "transcript",
+                "resume-hint"
+            ]
+        },
+        "fullscreenScrollbar": {
+            "label": "Fullscreen scrollbar",
+            "description": "Scrollbar behavior in fullscreen mode; has no effect in regular mode",
+            "opensDialog": false,
+            "values": [
+                "auto",
+                "always",
+                "hidden"
+            ]
+        },
+        "theme": {
+            "label": "Theme",
+            "description": "Color theme for the interface",
+            "opensDialog": true
+        }
+    },
+    "dialogs": {
+        "warnings": [
+            {
+                "id": "anthropic-extra-usage",
+                "label": "Anthropic extra usage",
+                "description": "Warn when Anthropic subscription auth may use paid extra usage",
+                "key": "anthropicExtraUsage",
+                "fallback": true
+            }
+        ]
+    },
+    "bounds": {
+        "imageWidthCells": {
+            "minimum": 1
+        },
+        "editorPaddingX": {
+            "minimum": 0,
+            "maximum": 3
+        },
+        "autocompleteMaxVisible": {
+            "minimum": 3,
+            "maximum": 20
+        }
+    }
+}

package/dist/src/foundation/pi-engine-adapter/public-main-entry.d.ts

@@ -0,0 +1,5 @@
+export interface PublicMainEntryDependencies {
+    readonly main?: (arguments_: string[]) => Promise<void>;
+    readonly stderr?: (message: string) => void;
+}
+export declare function runPublicMainEntry(arguments_: readonly string[], dependencies?: PublicMainEntryDependencies): Promise<number>;

package/dist/src/foundation/pi-engine-adapter/public-main-entry.js

@@ -0,0 +1,27 @@
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { main as runPublicMain } from "@earendil-works/pi-coding-agent";
+export async function runPublicMainEntry(arguments_, dependencies = {}) {
+    try {
+        await (dependencies.main ?? runPublicMain)([...arguments_]);
+        return 0;
+    }
+    catch (error) {
+        const detail = (error instanceof Error ? error.message : String(error)).replace(/[\r\n\t]+/g, " ").trim();
+        const bounded = detail.length > 400 ? `${detail.slice(0, 397)}...` : detail;
+        (dependencies.stderr ?? (message => process.stderr.write(message)))(`Selected Pi startup failed: ${bounded || "unknown error"}\n`);
+        return 1;
+    }
+}
+const isMain = process.argv[1] !== undefined && canonicalPath(process.argv[1]) === canonicalPath(fileURLToPath(import.meta.url));
+if (isMain)
+    process.exitCode = await runPublicMainEntry(process.argv.slice(2));
+function canonicalPath(path) {
+    try {
+        return realpathSync.native(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}

package/dist/src/foundation/pi-engine-adapter/resource-extension-integration.d.ts

@@ -0,0 +1,31 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { AgentExtensionBinding, AgentExtensionFailure, AgentExtensionPort, AgentResourceDescriptor, AgentResourcesPort, AgentSessionMetadata } from "../agent-engine-contracts/index.js";
+export interface PiResourceExtensionOptions {
+    readonly session: AgentSession;
+    readonly bindUi: () => Promise<void>;
+    readonly unbindUi: () => Promise<void>;
+}
+export declare class PiResourceExtensionIntegration implements AgentResourcesPort, AgentExtensionPort {
+    #private;
+    private readonly options;
+    readonly capabilities: {
+        reload: boolean;
+        extensionBinding: boolean;
+        binding: boolean;
+        renderers: boolean;
+    };
+    constructor(options: PiResourceExtensionOptions);
+    discoverResources(): Promise<readonly AgentResourceDescriptor[]>;
+    discoverCommands(): Promise<{
+        name: string;
+        description: string;
+    }[]>;
+    sessionMetadata(): Promise<AgentSessionMetadata>;
+    bind(sessionId: string): Promise<AgentExtensionBinding>;
+    bindExtensions(sessionId: string): Promise<AgentExtensionBinding>;
+    reload(): Promise<void>;
+    resolveMessageRenderer(customType: string): unknown;
+    resolveToolRenderer(toolName: string): unknown;
+    subscribeFailures(listener: (failure: AgentExtensionFailure) => void): () => void;
+    dispose(): Promise<void>;
+}