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

package/dist/integrations/pi/engine/package-integration.js

@@ -0,0 +1,118 @@
+import { join } from "node:path";
+import { DefaultPackageManager, ModelRuntime, SettingsManager } from "../startup-public.js";
+import { agentPackageOutcome, } from "../../../contracts/agent-engine/index.js";
+const MODEL_REFRESH_TIMEOUT_MS = 15_000;
+/**
+ * Pinned Pi's package manager already takes the profile root as an argument, so
+ * this binds it to the root A1 chose rather than to whatever the configuration-root
+ * environment variable happens to say. Pi's own package command handler is not used:
+ * it prints Pi's command names and ends the process, and both of those belong to
+ * whichever A1 command is running.
+ *
+ * The settings manager is created with project trust withheld, which is what keeps
+ * every operation to the user scope of the selected profile — a project-local
+ * `packages` list is never read, so it can never be written either.
+ */
+export function createPiPackagesPort(input) {
+    const { profileRoot, cwd } = input;
+    // Compatibility: model-only refresh bypasses package settings and their diagnostics, as Pi does.
+    let packageManager;
+    const manager = () => {
+        if (packageManager)
+            return packageManager;
+        const settingsManager = SettingsManager.create(cwd, profileRoot, { projectTrusted: false });
+        for (const { scope, error } of settingsManager.drainErrors()) {
+            input.onDiagnostic?.({
+                message: `Warning (package command, ${scope} settings): ${error.message}`,
+                ...(error.stack ? { detail: error.stack } : {}),
+            });
+        }
+        packageManager = new DefaultPackageManager({ cwd, agentDir: profileRoot, settingsManager });
+        packageManager.setProgressCallback(event => {
+            if (event.type !== "start")
+                return;
+            input.onProgress?.({ operation: operationFor(event.action), message: String(event.message) });
+        });
+        return packageManager;
+    };
+    const configured = () => manager().listConfiguredPackages()
+        .filter(entry => entry.scope === "user")
+        .map(entry => Object.freeze({
+        source: entry.source,
+        installedPath: entry.installedPath ?? null,
+        filtered: entry.filtered,
+    }));
+    return Object.freeze({
+        capabilities: Object.freeze({ install: true, remove: true, update: true, refreshModels: true }),
+        profileRoot,
+        async list() {
+            return await attempt("list", null, async () => agentPackageOutcome("list", "completed", null, null, configured()));
+        },
+        async install(source) {
+            return await attempt("install", source, async () => {
+                await manager().installAndPersist(source);
+                return agentPackageOutcome("install", "completed", null, source, configured());
+            });
+        },
+        async remove(source) {
+            return await attempt("remove", source, async () => {
+                const removed = await manager().removeAndPersist(source);
+                if (!removed)
+                    return agentPackageOutcome("remove", "not-found", null, source);
+                return agentPackageOutcome("remove", "completed", null, source, configured());
+            });
+        },
+        async update(source) {
+            return await attempt("update", source ?? null, async () => {
+                // Compatibility: Pi owns source identity and its contextual no-match suggestions.
+                await manager().update(source);
+                return agentPackageOutcome("update", "completed", null, source ?? null, configured());
+            });
+        },
+        async refreshModels() {
+            return await attempt("refresh-models", null, async () => {
+                await refreshModelCatalogs(profileRoot);
+                return agentPackageOutcome("refresh-models", "completed");
+            });
+        },
+    });
+}
+async function attempt(operation, source, run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : operation === "refresh-models"
+            ? "Unknown model catalog refresh error" : "Unknown package command error";
+        return agentPackageOutcome(operation, "failed", detail, source);
+    }
+}
+async function refreshModelCatalogs(profileRoot) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), MODEL_REFRESH_TIMEOUT_MS);
+    try {
+        const modelRuntime = await ModelRuntime.create({
+            authPath: join(profileRoot, "auth.json"),
+            modelsPath: join(profileRoot, "models.json"),
+            allowModelNetwork: false,
+            signal: controller.signal,
+        });
+        const result = await modelRuntime.refresh({ allowNetwork: true, force: true, signal: controller.signal });
+        if (result.aborted)
+            throw new Error("Model catalog refresh timed out.");
+        if (result.errors.size > 0) {
+            const details = Array.from(result.errors, ([provider, error]) => `${provider}: ${error.message}`).join("; ");
+            throw new Error(`Could not refresh model catalogs: ${details}`);
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function operationFor(action) {
+    if (action === "install")
+        return "install";
+    if (action === "remove")
+        return "remove";
+    return "update";
+}

package/dist/integrations/pi/engine/pending-delivery.d.ts

@@ -0,0 +1,30 @@
+import type { OwnedUiEvent } from "../../../contracts/owned-ui/index.js";
+export declare const MAX_PENDING_EVENTS = 1024;
+export declare const MAX_PENDING_EVENT_BYTES: number;
+/** Actual shell semantics: only live complete block state has no independent side effect. */
+export declare function replaceableEventKey(event: OwnedUiEvent): string | null;
+/** Intrusive FIFO + segment index: replacement unlinks in O(1), never changes source ordering. */
+export declare class PendingEngineDelivery {
+    #private;
+    private readonly retain;
+    constructor(retain?: (event: OwnedUiEvent) => () => void);
+    get size(): number;
+    diagnostics(): {
+        pending: number;
+        bytes: number;
+        protected: number;
+        superseded: number;
+        peakNodes: number;
+        peakBytes: number;
+    };
+    /** False means not admitted. The caller must enter its reserved recovery protocol, never evict. */
+    push(event: OwnedUiEvent, generation: number, reconcile?: () => OwnedUiEvent): boolean;
+    /** Session replacement invalidates old view state without resolving its lazy block references. */
+    discardObsolete(generation: number): number;
+    shift(): {
+        event: OwnedUiEvent;
+        generation: number;
+        release?: (() => void) | undefined;
+    } | undefined;
+    seal(): boolean;
+}

package/dist/integrations/pi/engine/pending-delivery.js

@@ -0,0 +1,156 @@
+export const MAX_PENDING_EVENTS = 1024;
+export const MAX_PENDING_EVENT_BYTES = 8 * 1024 * 1024;
+/** Actual shell semantics: only live complete block state has no independent side effect. */
+export function replaceableEventKey(event) {
+    switch (event.type) {
+        case "transcript-block": return event.block.status === "live" && !(typeof event.block.payload === "object" && event.block.payload !== null && "isError" in event.block.payload && event.block.payload.isError === true) ? event.block.id : null;
+        case "session-view": // Invariant: may clear compaction work, replace editor/session state, or preempt presentation.
+        case "status": // Invariant: retry/compaction transitions invalidate suggestion work.
+        case "editor-state":
+        case "terminal-surface":
+        case "session-lifecycle":
+        case "agent-run-started":
+        case "agent-run-settled":
+        case "assistant-message-completed":
+        case "command-outcome":
+        case "diagnostic":
+        case "dialog":
+        case "overlay":
+        case "customization": return null;
+        default: {
+            const exhaustive = event;
+            return exhaustive;
+        }
+    }
+}
+/** Intrusive FIFO + segment index: replacement unlinks in O(1), never changes source ordering. */
+export class PendingEngineDelivery {
+    #replaceable = new Map();
+    #head;
+    #tail;
+    #size = 0;
+    #bytes = 0;
+    #protected = 0;
+    #generation = -1;
+    #superseded = 0;
+    #peakNodes = 0;
+    #peakBytes = 0;
+    retain;
+    constructor(retain) { this.retain = retain; }
+    get size() { return this.#size; }
+    diagnostics() {
+        return { pending: this.#size, bytes: this.#bytes, protected: this.#protected,
+            superseded: this.#superseded, peakNodes: this.#peakNodes, peakBytes: this.#peakBytes };
+    }
+    /** False means not admitted. The caller must enter its reserved recovery protocol, never evict. */
+    push(event, generation, reconcile) {
+        const key = replaceableEventKey(event);
+        if (generation !== this.#generation || key === null) {
+            if (!this.seal())
+                return false;
+            this.#generation = generation;
+        }
+        const prior = key === null ? undefined : this.#replaceable.get(key);
+        let bytes = retainedEventBytes(event);
+        const marker = key !== null && bytes > 64 * 1024 && reconcile !== undefined;
+        if (marker)
+            bytes = 128;
+        if (this.#size - (prior === undefined ? 0 : 1) >= MAX_PENDING_EVENTS
+            || this.#bytes - (prior?.bytes ?? 0) + bytes > MAX_PENDING_EVENT_BYTES)
+            return false;
+        const node = { key, generation, bytes, ...(marker ? { resolve: reconcile } : { event, release: this.retain?.(event) }) };
+        if (prior !== undefined) {
+            this.#unlink(prior);
+            this.#superseded = Math.min(Number.MAX_SAFE_INTEGER, this.#superseded + 1);
+        }
+        node.previous = this.#tail;
+        if (this.#tail !== undefined)
+            this.#tail.next = node;
+        else
+            this.#head = node;
+        this.#tail = node;
+        this.#size++;
+        this.#bytes += bytes;
+        if (key === null)
+            this.#protected++;
+        else
+            this.#replaceable.set(key, node);
+        this.#peakNodes = Math.max(this.#peakNodes, this.#size);
+        this.#peakBytes = Math.max(this.#peakBytes, this.#bytes);
+        return true;
+    }
+    /** Session replacement invalidates old view state without resolving its lazy block references. */
+    discardObsolete(generation) {
+        let discarded = 0;
+        let node = this.#head;
+        while (node !== undefined) {
+            const next = node.next;
+            if (node.generation !== generation && node.event?.type !== "command-outcome") {
+                this.#unlink(node);
+                discarded++;
+            }
+            node = next;
+        }
+        this.#replaceable.clear();
+        this.#generation = generation;
+        return discarded;
+    }
+    shift() {
+        const node = this.#head;
+        if (node === undefined)
+            return undefined;
+        const event = node.event ?? node.resolve();
+        const release = node.release ?? this.retain?.(event);
+        this.#unlink(node, false);
+        // Invariant: a consumed snapshot retains its assets through synchronous listener delivery, including reentrant production.
+        return { event, generation: node.generation, ...(release === undefined ? {} : { release }) };
+    }
+    // Invariant: a barrier freezes lazy authoritative markers before a later segment can change them.
+    seal() {
+        for (const node of this.#replaceable.values()) {
+            if (node.resolve === undefined)
+                continue;
+            const event = node.resolve();
+            const bytes = retainedEventBytes(event);
+            if (this.#bytes - node.bytes + bytes > MAX_PENDING_EVENT_BYTES)
+                return false;
+            this.#bytes += bytes - node.bytes;
+            node.bytes = bytes;
+            node.event = event;
+            node.resolve = undefined;
+            node.release = this.retain?.(event);
+            this.#peakBytes = Math.max(this.#peakBytes, this.#bytes);
+        }
+        this.#replaceable.clear();
+        return true;
+    }
+    #unlink(node, release = true) {
+        if (release)
+            node.release?.();
+        if (node.previous !== undefined)
+            node.previous.next = node.next;
+        else
+            this.#head = node.next;
+        if (node.next !== undefined)
+            node.next.previous = node.previous;
+        else
+            this.#tail = node.previous;
+        this.#size--;
+        this.#bytes -= node.bytes;
+        if (node.key === null)
+            this.#protected--;
+        else if (this.#replaceable.get(node.key) === node)
+            this.#replaceable.delete(node.key);
+    }
+}
+/** Conservative UTF-16 payload bound. String length is O(1); never encode accumulated text per chunk. */
+function retainedEventBytes(value) {
+    if (typeof value === "string")
+        return 16 + value.length * 2;
+    if (value === null || typeof value !== "object")
+        return 8;
+    let bytes = 32;
+    for (const [key, item] of Object.entries(value))
+        bytes += 16 + key.length * 2 + retainedEventBytes(item);
+    return bytes;
+}

package/dist/integrations/pi/engine/pi-settings-metadata.json

@@ -0,0 +1,385 @@
+{
+  "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",
+    "modelThinkingLevels",
+    "tuiMode",
+    "fullscreenExitOutput",
+    "fullscreenScrollbar",
+    "fullscreenCopyOnSelect",
+    "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",
+    "modelThinkingLevels",
+    "tuiMode",
+    "fullscreenExitOutput",
+    "fullscreenScrollbar",
+    "fullscreenCopyOnSelect",
+    "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": "'one-at-a-time': deliver one, wait for response. 'all': deliver all at once.",
+      "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 cache costs and provider recovery diagnostics",
+      "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"
+    },
+    "modelThinkingLevels": {
+      "label": "Default thinking level per model",
+      "description": "Override the default thinking level for specific 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"
+      ]
+    },
+    "fullscreenCopyOnSelect": {
+      "label": "Fullscreen copy on select",
+      "description": "Automatically copy selected text in fullscreen mode; disable to copy selections with Ctrl+X",
+      "opensDialog": false,
+      "values": [
+        "true",
+        "false"
+      ]
+    },
+    "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
+    }
+  }
+}