@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/coding-agent/utils/abort.d.ts

@@ -0,0 +1,4 @@
+/** Normalize an optional public signal without imposing a deadline. */
+export declare function andorraOperationSignal(signal?: AbortSignal): AbortSignal;
+/** Stop waiting on abort while observing the abandoned operation through settlement. */
+export declare function andorraRaceWithAbortSignal<T>(operation: Promise<T>, signal: AbortSignal | undefined): Promise<T>;

package/dist/vendor/engine/runtime/coding-agent/utils/abort.js

@@ -0,0 +1,47 @@
+function andorraAbortReason(signal) {
+    if (signal.reason !== undefined)
+        return signal.reason;
+    const error = new Error("The operation was aborted");
+    error.name = "AbortError";
+    return error;
+}
+/** Normalize an optional public signal without imposing a deadline. */
+export function andorraOperationSignal(signal) {
+    return signal ?? new AbortController().signal;
+}
+/** Stop waiting on abort while observing the abandoned operation through settlement. */
+export function andorraRaceWithAbortSignal(operation, signal) {
+    if (!signal)
+        return operation;
+    if (signal.aborted) {
+        void operation.catch(() => { });
+        return Promise.reject(andorraAbortReason(signal));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const andorraCleanup = () => signal.removeEventListener("abort", andorraOnAbort);
+        const andorraOnAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            andorraCleanup();
+            reject(andorraAbortReason(signal));
+        };
+        signal.addEventListener("abort", andorraOnAbort, { once: true });
+        void operation.then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            andorraCleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            andorraCleanup();
+            reject(error);
+        });
+        if (signal.aborted)
+            andorraOnAbort();
+    });
+}

package/dist/vendor/engine/runtime/coding-agent/utils/ansi.d.ts

@@ -0,0 +1 @@
+export declare function andorraStripAnsi(value: string): string;

package/dist/vendor/engine/runtime/coding-agent/utils/ansi.js

@@ -0,0 +1,51 @@
+/*
+ * Portions of this file are derived from:
+ * - ansi-regex (https://github.com/chalk/ansi-regex)
+ * - strip-ansi (https://github.com/chalk/strip-ansi)
+ *
+ * MIT License
+ *
+ * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+function andorraAnsiRegex({ onlyFirst = false } = {}) {
+    // Valid string terminator sequences are BEL, ESC\, and 0x9c
+    const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+    // OSC sequences only: ESC ] ... ST (non-greedy until the first ST)
+    const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+    // CSI and related: ESC/C1, optional intermediates, optional params (supports ; and :) then final byte
+    const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+    const pattern = `${osc}|${csi}`;
+    return new RegExp(pattern, onlyFirst ? undefined : "g");
+}
+const regex = andorraAnsiRegex();
+export function andorraStripAnsi(value) {
+    if (typeof value !== "string") {
+        throw new TypeError(`Expected a \`string\`, got \`${typeof value}\``);
+    }
+    // Fast path: ANSI codes require ESC (7-bit) or CSI (8-bit) introducer
+    if (!value.includes("\u001B") && !value.includes("\u009B")) {
+        return value;
+    }
+    // Even though the regex is global, we don't need to reset the `.lastIndex`
+    // because unlike `.exec()` and `.test()`, `.replace()` does it automatically
+    // and doing it manually has a performance penalty.
+    return value.replace(regex, "");
+}

package/dist/vendor/engine/runtime/coding-agent/utils/changelog.d.ts

@@ -0,0 +1,21 @@
+export interface ChangelogEntry {
+    major: number;
+    minor: number;
+    patch: number;
+    content: string;
+}
+export declare function andorraNormalizeChangelogLinks(markdown: string, version: string | ChangelogEntry): string;
+/**
+ * Parse changelog entries from CHANGELOG.md
+ * Scans for ## lines and collects content until next ## or EOF
+ */
+export declare function andorraParseChangelog(changelogPath: string): ChangelogEntry[];
+/**
+ * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+export declare function andorraCompareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number;
+/**
+ * Get entries newer than lastVersion
+ */
+export declare function andorraGetNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[];
+export { andorraGetChangelogPath } from "../config.js";

package/dist/vendor/engine/runtime/coding-agent/utils/changelog.js

@@ -0,0 +1,164 @@
+import path from "node:path";
+import { existsSync, readFileSync } from "fs";
+const GITHUB_REPO = "earendil-works/pi";
+const CHANGELOG_LINK_BASE_PATH = "packages/coding-agent";
+const LEGACY_REPO_RE = /^https:\/\/github\.com\/(?:badlogic|earendil-works)\/pi-mono(?=\/|$)/;
+const URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+const INLINE_MARKDOWN_LINK_RE = /(!?\[[^\]\n]+\]\()([^\s)]+)((?:\s+[^)]*)?\))/g;
+function andorraEntryVersion(entry) {
+    return `${entry.major}.${entry.minor}.${entry.patch}`;
+}
+function andorraNormalizeTag(version) {
+    const versionString = typeof version === "string" ? version : andorraEntryVersion(version);
+    return versionString.startsWith("v") ? versionString : `v${versionString}`;
+}
+function andorraSplitLocalTarget(target) {
+    const hashIndex = target.indexOf("#");
+    const beforeHash = hashIndex === -1 ? target : target.slice(0, hashIndex);
+    const fragment = hashIndex === -1 ? "" : target.slice(hashIndex);
+    const queryIndex = beforeHash.indexOf("?");
+    if (queryIndex === -1) {
+        return { fragment, pathPart: beforeHash, query: "" };
+    }
+    return {
+        fragment,
+        pathPart: beforeHash.slice(0, queryIndex),
+        query: beforeHash.slice(queryIndex),
+    };
+}
+function andorraNormalizePathPart(value) {
+    return value.replaceAll("\\", "/");
+}
+function andorraResolveRepositoryPath(targetPath) {
+    const normalizedTarget = andorraNormalizePathPart(targetPath);
+    const joined = normalizedTarget.startsWith("/")
+        ? path.posix.normalize(normalizedTarget.replace(/^\/+/, ""))
+        : path.posix.normalize(path.posix.join(CHANGELOG_LINK_BASE_PATH, normalizedTarget));
+    if (joined === "." || joined.startsWith("../") || joined === "..") {
+        return undefined;
+    }
+    return joined;
+}
+function andorraIsDirectoryTarget(originalPath, repositoryPath) {
+    if (originalPath.endsWith("/")) {
+        return true;
+    }
+    const basename = path.posix.basename(repositoryPath);
+    return !basename.includes(".");
+}
+function andorraNormalizeChangelogLinkTarget(target, tag) {
+    let canonicalTarget = target.replace(LEGACY_REPO_RE, `https://github.com/${GITHUB_REPO}`);
+    const repoUrl = `https://github.com/${GITHUB_REPO}`;
+    for (const route of ["blob", "tree"]) {
+        for (const branch of ["main", "master"]) {
+            const floatingRefPrefix = `${repoUrl}/${route}/${branch}/`;
+            if (canonicalTarget.startsWith(floatingRefPrefix)) {
+                canonicalTarget = `${repoUrl}/${route}/${tag}/${canonicalTarget.slice(floatingRefPrefix.length)}`;
+            }
+        }
+    }
+    if (canonicalTarget.startsWith("#") || canonicalTarget.startsWith("//") || URL_SCHEME_RE.test(canonicalTarget)) {
+        return canonicalTarget;
+    }
+    const { fragment, pathPart, query } = andorraSplitLocalTarget(canonicalTarget);
+    if (!pathPart) {
+        return canonicalTarget;
+    }
+    const repositoryPath = andorraResolveRepositoryPath(pathPart);
+    if (!repositoryPath) {
+        return canonicalTarget;
+    }
+    const route = andorraIsDirectoryTarget(pathPart, repositoryPath) ? "tree" : "blob";
+    return `https://github.com/${GITHUB_REPO}/${route}/${tag}/${encodeURI(repositoryPath)}${query}${fragment}`;
+}
+export function andorraNormalizeChangelogLinks(markdown, version) {
+    const tag = andorraNormalizeTag(version);
+    return markdown.replace(INLINE_MARKDOWN_LINK_RE, (_match, prefix, target, suffix) => {
+        return `${prefix}${andorraNormalizeChangelogLinkTarget(target, tag)}${suffix}`;
+    });
+}
+/**
+ * Parse changelog entries from CHANGELOG.md
+ * Scans for ## lines and collects content until next ## or EOF
+ */
+export function andorraParseChangelog(changelogPath) {
+    if (!existsSync(changelogPath)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(changelogPath, "utf-8");
+        const lines = content.split("\n");
+        const entries = [];
+        let currentLines = [];
+        let currentVersion = null;
+        for (const line of lines) {
+            // Check if this is a version header (## [x.y.z] ...)
+            if (line.startsWith("## ")) {
+                // Save previous entry if exists
+                if (currentVersion && currentLines.length > 0) {
+                    entries.push({
+                        ...currentVersion,
+                        content: currentLines.join("\n").trim(),
+                    });
+                }
+                // Try to parse version from this line
+                const versionMatch = line.match(/##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/);
+                if (versionMatch) {
+                    currentVersion = {
+                        major: Number.parseInt(versionMatch[1], 10),
+                        minor: Number.parseInt(versionMatch[2], 10),
+                        patch: Number.parseInt(versionMatch[3], 10),
+                    };
+                    currentLines = [line];
+                }
+                else {
+                    // Reset if we can't parse version
+                    currentVersion = null;
+                    currentLines = [];
+                }
+            }
+            else if (currentVersion) {
+                // Collect lines for current version
+                currentLines.push(line);
+            }
+        }
+        // Save last entry
+        if (currentVersion && currentLines.length > 0) {
+            entries.push({
+                ...currentVersion,
+                content: currentLines.join("\n").trim(),
+            });
+        }
+        return entries;
+    }
+    catch (error) {
+        console.error(`Warning: Could not parse changelog: ${error}`);
+        return [];
+    }
+}
+/**
+ * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+export function andorraCompareVersions(v1, v2) {
+    if (v1.major !== v2.major)
+        return v1.major - v2.major;
+    if (v1.minor !== v2.minor)
+        return v1.minor - v2.minor;
+    return v1.patch - v2.patch;
+}
+/**
+ * Get entries newer than lastVersion
+ */
+export function andorraGetNewEntries(entries, lastVersion) {
+    // Parse lastVersion
+    const parts = lastVersion.split(".").map(Number);
+    const last = {
+        major: parts[0] || 0,
+        minor: parts[1] || 0,
+        patch: parts[2] || 0,
+        content: "",
+    };
+    return entries.filter((entry) => andorraCompareVersions(entry, last) > 0);
+}
+// Re-export getChangelogPath from paths.ts for convenience
+export { andorraGetChangelogPath } from "../config.js";

package/dist/vendor/engine/runtime/coding-agent/utils/child-process.d.ts

@@ -0,0 +1,17 @@
+import { type ChildProcess, type ChildProcessByStdio, type SpawnOptions, type SpawnOptionsWithStdioTuple, type SpawnSyncOptionsWithStringEncoding, type SpawnSyncReturns, type StdioNull, type StdioPipe } from "node:child_process";
+import type { Readable } from "node:stream";
+export declare function andorraSpawnProcess(command: string, args: string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): ChildProcessByStdio<null, Readable, Readable>;
+export declare function andorraSpawnProcess(command: string, args: string[], options: SpawnOptions): ChildProcess;
+export declare function andorraSpawnProcessSync(command: string, args: string[], options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
+/**
+ * Wait for a child process to terminate without hanging on inherited stdio handles.
+ *
+ * A short-lived child can `exit` while a detached descendant keeps its stdout/stderr
+ * pipe open. We must not resolve and destroy the streams on a fixed deadline measured
+ * from `exit`, or output still being written past that deadline is silently lost
+ * (earendil-works/pi#5303). Instead, after `exit` we wait for the pipes to fall idle:
+ * the grace timer is re-armed on every chunk, so an actively writing descendant keeps
+ * us reading, while a quiet inherited handle (e.g. a Windows daemonized descendant
+ * that never lets `close` fire) still releases us after the grace elapses.
+ */
+export declare function andorraWaitForChildProcess(child: ChildProcess): Promise<number | null>;

package/dist/vendor/engine/runtime/coding-agent/utils/child-process.js

@@ -0,0 +1,105 @@
+import { spawn as nodeSpawn, spawnSync as nodeSpawnSync, } from "node:child_process";
+import crossSpawn from "cross-spawn";
+const EXIT_STDIO_GRACE_MS = 100;
+export function andorraSpawnProcess(command, args, options) {
+    return process.platform === "win32" ? crossSpawn(command, args, options) : nodeSpawn(command, args, options);
+}
+export function andorraSpawnProcessSync(command, args, options) {
+    return process.platform === "win32"
+        ? crossSpawn.sync(command, args, options)
+        : nodeSpawnSync(command, args, options);
+}
+/**
+ * Wait for a child process to terminate without hanging on inherited stdio handles.
+ *
+ * A short-lived child can `exit` while a detached descendant keeps its stdout/stderr
+ * pipe open. We must not resolve and destroy the streams on a fixed deadline measured
+ * from `exit`, or output still being written past that deadline is silently lost
+ * (earendil-works/pi#5303). Instead, after `exit` we wait for the pipes to fall idle:
+ * the grace timer is re-armed on every chunk, so an actively writing descendant keeps
+ * us reading, while a quiet inherited handle (e.g. a Windows daemonized descendant
+ * that never lets `close` fire) still releases us after the grace elapses.
+ */
+export function andorraWaitForChildProcess(child) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let exited = false;
+        let exitCode = null;
+        let postExitTimer;
+        let stdoutEnded = child.stdout === null;
+        let stderrEnded = child.stderr === null;
+        const andorraCleanup = () => {
+            if (postExitTimer) {
+                clearTimeout(postExitTimer);
+                postExitTimer = undefined;
+            }
+            child.removeListener("error", andorraOnError);
+            child.removeListener("exit", andorraOnExit);
+            child.removeListener("close", andorraOnClose);
+            child.stdout?.removeListener("end", andorraOnStdoutEnd);
+            child.stderr?.removeListener("end", andorraOnStderrEnd);
+            child.stdout?.removeListener("data", andorraOnData);
+            child.stderr?.removeListener("data", andorraOnData);
+        };
+        const andorraFinalize = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            andorraCleanup();
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            resolve(code);
+        };
+        const andorraMaybeFinalizeAfterExit = () => {
+            if (!exited || settled)
+                return;
+            if (stdoutEnded && stderrEnded) {
+                andorraFinalize(exitCode);
+            }
+        };
+        const andorraArmIdleTimer = () => {
+            if (postExitTimer)
+                clearTimeout(postExitTimer);
+            postExitTimer = setTimeout(() => andorraFinalize(exitCode), EXIT_STDIO_GRACE_MS);
+        };
+        const andorraOnData = () => {
+            // Output is still arriving after exit; defer finalizing so we don't
+            // destroy the stream mid-write and truncate the tail.
+            if (exited && !settled)
+                andorraArmIdleTimer();
+        };
+        const andorraOnStdoutEnd = () => {
+            stdoutEnded = true;
+            andorraMaybeFinalizeAfterExit();
+        };
+        const andorraOnStderrEnd = () => {
+            stderrEnded = true;
+            andorraMaybeFinalizeAfterExit();
+        };
+        const andorraOnError = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            andorraCleanup();
+            reject(err);
+        };
+        const andorraOnExit = (code) => {
+            exited = true;
+            exitCode = code;
+            andorraMaybeFinalizeAfterExit();
+            if (!settled) {
+                andorraArmIdleTimer();
+            }
+        };
+        const andorraOnClose = (code) => {
+            andorraFinalize(code);
+        };
+        child.stdout?.once("end", andorraOnStdoutEnd);
+        child.stderr?.once("end", andorraOnStderrEnd);
+        child.stdout?.on("data", andorraOnData);
+        child.stderr?.on("data", andorraOnData);
+        child.once("error", andorraOnError);
+        child.once("exit", andorraOnExit);
+        child.once("close", andorraOnClose);
+    });
+}

package/dist/vendor/engine/runtime/coding-agent/utils/clipboard-command.d.ts

@@ -0,0 +1,6 @@
+/** Undefined means the command failed; an empty buffer is a successful result. */
+export declare function andorraRunClipboardCommand(command: string, args: readonly string[], options?: {
+    input?: string;
+    timeoutMs?: number;
+    maxBufferBytes?: number;
+}): Promise<Buffer | undefined>;

package/dist/vendor/engine/runtime/coding-agent/utils/clipboard-command.js

@@ -0,0 +1,44 @@
+import { spawn } from "node:child_process";
+/** Undefined means the command failed; an empty buffer is a successful result. */
+export function andorraRunClipboardCommand(command, args, options) {
+    return new Promise((resolve) => {
+        // Clipboard writers can daemonize. Do not give them output pipes to retain.
+        const child = spawn(command, args, {
+            stdio: ["pipe", options?.input === undefined ? "pipe" : "ignore", "ignore"],
+            windowsHide: true,
+        });
+        const chunks = [];
+        let length = 0;
+        let settled = false;
+        const andorraFinish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const andorraAbort = () => {
+            child.kill("SIGKILL");
+            child.stdout?.destroy();
+            child.stdin?.destroy();
+            andorraFinish(undefined);
+        };
+        const timer = setTimeout(andorraAbort, options?.timeoutMs ?? 3000);
+        child.on("error", () => andorraFinish(undefined));
+        child.on("close", (code) => {
+            if (!settled)
+                andorraFinish(code === 0 ? Buffer.concat(chunks, length) : undefined);
+        });
+        child.stdout?.on("data", (chunk) => {
+            if (settled)
+                return;
+            length += chunk.length;
+            if (length > (options?.maxBufferBytes ?? 50 * 1024 * 1024))
+                andorraAbort();
+            else
+                chunks.push(chunk);
+        });
+        child.stdin?.on("error", () => { }); // A writer may exit before consuming all input.
+        child.stdin?.end(options?.input);
+    });
+}

package/dist/vendor/engine/runtime/coding-agent/utils/clipboard-image.d.ts

@@ -0,0 +1,10 @@
+export type ClipboardImage = {
+    bytes: Uint8Array;
+    mimeType: string;
+};
+export declare function andorraIsWaylandSession(env?: NodeJS.ProcessEnv): boolean;
+export declare function andorraExtensionForImageMimeType(mimeType: string): string | null;
+export declare function andorraReadClipboardImage(options?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+}): Promise<ClipboardImage | null>;