@timurproko/a1 0.1.8-dev.299 → 0.1.8-dev.332

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

@@ -0,0 +1,2 @@
+export declare function readPinnedCommandChangelog(sinceVersion?: string): Promise<string>;
+export declare function formatPinnedCommandChangelog(content: string, sinceVersion?: string): string;

package/dist/integrations/pi/engine/changelog.js

@@ -0,0 +1,63 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { posix } from "node:path";
+const REPOSITORY = "https://github.com/earendil-works/pi";
+export async function readPinnedCommandChangelog(sinceVersion) {
+    const path = new URL("./resources/changelog.json", import.meta.url);
+    if (!existsSync(path))
+        return sinceVersion === undefined ? "No changelog entries found." : "";
+    try {
+        const resource = JSON.parse(await readFile(path, "utf8"));
+        if (!resource || typeof resource !== "object" || !("data" in resource) || typeof resource.data !== "string")
+            throw new TypeError("Invalid owned changelog resource");
+        const markdown = resource.data;
+        return formatPinnedCommandChangelog(markdown, sinceVersion);
+    }
+    catch (error) {
+        // Compatibility: Pi's data-file parser reports a warning and supplies an empty changelog.
+        console.error(`Warning: Could not parse changelog: ${error}`);
+        return sinceVersion === undefined ? "No changelog entries found." : "";
+    }
+}
+export function formatPinnedCommandChangelog(content, sinceVersion) {
+    // Provenance: behavior follows Pi 0.84.2 utils/changelog.ts at 914cf1472e715297caa30db4b9535d534a9eb718.
+    // Runtime reads only the owned data resource; maintenance tooling verifies its pinned provenance.
+    let releases = content.split(/(?=^## )/m).flatMap((section) => {
+        const version = /^##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/.exec(section);
+        return version ? [{ version: version.slice(1).map(Number), markdown: section.trim() }] : [];
+    });
+    if (sinceVersion !== undefined) {
+        const previous = sinceVersion.split(".").map(value => Number(value) || 0);
+        releases = releases.filter(release => {
+            for (let index = 0; index < 3; index++) {
+                const difference = release.version[index] - (previous[index] ?? 0);
+                if (difference !== 0)
+                    return difference > 0;
+            }
+            return false;
+        });
+    }
+    else
+        releases.reverse();
+    if (releases.length === 0)
+        return sinceVersion === undefined ? "No changelog entries found." : "";
+    return releases.map(release => release.markdown.replace(/(!?\[[^\]\n]+\]\()([^\s)]+)((?:\s+[^)]*)?\))/g, (_match, prefix, target, suffix) => `${prefix}${releaseLink(target, `v${release.version.join(".")}`)}${suffix}`)).join("\n\n");
+}
+function releaseLink(target, tag) {
+    const canonical = target
+        .replace(/^https:\/\/github\.com\/(?:badlogic|earendil-works)\/pi-mono(?=\/|$)/, REPOSITORY)
+        .replace(/^(https:\/\/github\.com\/earendil-works\/pi\/(?:blob|tree)\/)(?:main|master)\//, `$1${tag}/`);
+    if (/^(?:#|\/\/|[a-z][a-z0-9+.-]*:)/i.test(canonical))
+        return canonical;
+    const boundary = canonical.search(/[?#]/);
+    const path = boundary === -1 ? canonical : canonical.slice(0, boundary);
+    const suffix = boundary === -1 ? "" : canonical.slice(boundary);
+    if (!path)
+        return canonical;
+    const normalized = path.replaceAll("\\", "/");
+    const repositoryPath = posix.normalize(normalized.startsWith("/") ? normalized.replace(/^\/+/, "") : posix.join("packages/coding-agent", normalized));
+    if (repositoryPath === "." || repositoryPath === ".." || repositoryPath.startsWith("../"))
+        return canonical;
+    const route = path.endsWith("/") || !posix.basename(repositoryPath).includes(".") ? "tree" : "blob";
+    return `${REPOSITORY}/${route}/${tag}/${encodeURI(repositoryPath)}${suffix}`;
+}

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

@@ -0,0 +1,26 @@
+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;
+    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;
+    } | undefined;
+}

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

@@ -0,0 +1,149 @@
+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;
+    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;
+        if (prior !== undefined) {
+            this.#unlink(prior);
+            this.#superseded = Math.min(Number.MAX_SAFE_INTEGER, this.#superseded + 1);
+        }
+        const node = { key, generation, bytes, ...(marker ? { resolve: reconcile } : { event }) };
+        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();
+        this.#unlink(node);
+        return { event, generation: node.generation };
+    }
+    // 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;
+            this.#peakBytes = Math.max(this.#peakBytes, this.#bytes);
+        }
+        this.#replaceable.clear();
+        return true;
+    }
+    #unlink(node) {
+        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;
+}