@slopus/rig 0.0.1

package/dist/app/formatSessionSummaries.js

@@ -0,0 +1,73 @@
+export function formatSessionSummaries(sessions, options) {
+    const visibleRows = Math.max(0, options.rows);
+    if (visibleRows === 0) {
+        return [];
+    }
+    if (sessions.length === 0) {
+        return [truncate("No sessions.", options.columns)];
+    }
+    const limit = Math.max(0, visibleRows - 1);
+    const lines = [
+        truncate("STATUS     LAST MESSAGE      SESSION ID              TITLE", options.columns),
+    ];
+    for (const session of sessions.slice(0, limit)) {
+        lines.push(truncate(formatSessionSummary(session), options.columns));
+    }
+    return lines;
+}
+function formatSessionSummary(session) {
+    return [
+        padRight(humanizeStatus(session.status), 10),
+        padRight(formatTimestamp(session.lastMessageAt), 17),
+        padRight(session.id, 23),
+        titleText(session),
+    ].join(" ");
+}
+function formatTimestamp(value) {
+    if (value === undefined) {
+        return "No messages";
+    }
+    const date = new Date(value);
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hour = String(date.getHours()).padStart(2, "0");
+    const minute = String(date.getMinutes()).padStart(2, "0");
+    return `${month}-${day} ${hour}:${minute}`;
+}
+function humanizeStatus(status) {
+    if (status === "idle")
+        return "Idle";
+    if (status === "queued")
+        return "Queued";
+    if (status === "running")
+        return "Running";
+    if (status === "completed")
+        return "Completed";
+    if (status === "aborted")
+        return "Aborted";
+    return "Error";
+}
+function padRight(value, length) {
+    return value.length >= length ? value : `${value}${" ".repeat(length - value.length)}`;
+}
+function titleText(session) {
+    if (session.title !== undefined && session.title.length > 0) {
+        return session.title;
+    }
+    if (session.titleStatus === "generating") {
+        return "Generating title";
+    }
+    return "Untitled session";
+}
+function truncate(value, columns) {
+    if (columns <= 0) {
+        return "";
+    }
+    if (value.length <= columns) {
+        return value;
+    }
+    if (columns === 1) {
+        return "…";
+    }
+    return `${value.slice(0, columns - 1)}…`;
+}

package/dist/app/highlightAgentCode.d.ts

@@ -0,0 +1,2 @@
+export declare function highlightAgentCode(code: string, lang?: string): string[];
+//# sourceMappingURL=highlightAgentCode.d.ts.map

package/dist/app/highlightAgentCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlightAgentCode.d.ts","sourceRoot":"","sources":["../../sources/app/highlightAgentCode.ts"],"names":[],"mappings":"AAuCA,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAOxE"}

package/dist/app/highlightAgentCode.js

@@ -0,0 +1,82 @@
+const FG_RESET = "\x1b[39m";
+const CODE_BLOCK = [181, 189, 104];
+const COMMENT = [106, 153, 85];
+const KEYWORD = [86, 156, 214];
+const NUMBER = [181, 206, 168];
+const STRING = [206, 145, 120];
+const TYPE = [78, 201, 176];
+const HIGHLIGHTED_LANGUAGES = new Set([
+    "bash",
+    "c",
+    "cpp",
+    "css",
+    "go",
+    "html",
+    "java",
+    "javascript",
+    "json",
+    "jsx",
+    "python",
+    "ruby",
+    "rust",
+    "sh",
+    "shell",
+    "sql",
+    "tsx",
+    "typescript",
+    "yaml",
+    "zsh",
+]);
+const KEYWORD_PATTERN = /\b(?:async|await|break|case|catch|class|const|continue|def|defer|else|enum|export|extends|false|for|from|func|function|go|if|impl|import|interface|let|new|null|package|private|protected|public|return|select|struct|switch|true|try|type|use|var|while)\b/g;
+const TYPE_PATTERN = /\b(?:Array|Boolean|Error|Map|Number|Promise|Record|Set|String|unknown|void)\b/g;
+const NUMBER_PATTERN = /\b\d+(?:\.\d+)?\b/g;
+const STRING_PATTERN = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)/g;
+export function highlightAgentCode(code, lang) {
+    const normalizedLang = lang?.toLowerCase();
+    if (normalizedLang === undefined || !HIGHLIGHTED_LANGUAGES.has(normalizedLang)) {
+        return code.split("\n").map((line) => fg(CODE_BLOCK, line));
+    }
+    return code.split("\n").map((line) => highlightLine(line, normalizedLang));
+}
+function highlightLine(line, lang) {
+    const commentStart = commentIndex(line, lang);
+    const codePart = commentStart === -1 ? line : line.slice(0, commentStart);
+    const commentPart = commentStart === -1 ? "" : line.slice(commentStart);
+    const highlightedCode = highlightCodePart(codePart);
+    return commentPart.length === 0
+        ? highlightedCode
+        : `${highlightedCode}${fg(COMMENT, commentPart)}`;
+}
+function highlightCodePart(line) {
+    let result = "";
+    let cursor = 0;
+    for (const match of line.matchAll(STRING_PATTERN)) {
+        const index = match.index ?? 0;
+        const value = match[0] ?? "";
+        result += highlightPlainSegment(line.slice(cursor, index));
+        result += fg(STRING, value);
+        cursor = index + value.length;
+    }
+    result += highlightPlainSegment(line.slice(cursor));
+    return result;
+}
+function highlightPlainSegment(segment) {
+    return segment
+        .replace(TYPE_PATTERN, (value) => fg(TYPE, value))
+        .replace(KEYWORD_PATTERN, (value) => fg(KEYWORD, value))
+        .replace(NUMBER_PATTERN, (value) => fg(NUMBER, value));
+}
+function commentIndex(line, lang) {
+    if (lang === "python" ||
+        lang === "ruby" ||
+        lang === "bash" ||
+        lang === "sh" ||
+        lang === "shell" ||
+        lang === "zsh") {
+        return line.indexOf("#");
+    }
+    return line.indexOf("//");
+}
+function fg(color, text) {
+    return `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${text}${FG_RESET}`;
+}

package/dist/app/humanizeProviderId.d.ts

@@ -0,0 +1,2 @@
+export declare function humanizeProviderId(providerId: string): string;
+//# sourceMappingURL=humanizeProviderId.d.ts.map

package/dist/app/humanizeProviderId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"humanizeProviderId.d.ts","sourceRoot":"","sources":["../../sources/app/humanizeProviderId.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAsB7D"}

package/dist/app/humanizeProviderId.js

@@ -0,0 +1,22 @@
+export function humanizeProviderId(providerId) {
+    if (providerId === "bedrock") {
+        return "Amazon Bedrock";
+    }
+    if (providerId === "codex") {
+        return "Codex";
+    }
+    if (providerId === "claude-sdk") {
+        return "Claude SDK";
+    }
+    if (providerId === "anthropic") {
+        return "Anthropic";
+    }
+    if (providerId === "openai") {
+        return "OpenAI";
+    }
+    return providerId
+        .split(/[-_\s]+/u)
+        .filter((part) => part.length > 0)
+        .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+        .join(" ");
+}

package/dist/app/humanizeReasoningLevel.d.ts

@@ -0,0 +1,2 @@
+export declare function humanizeReasoningLevel(level: string): string;
+//# sourceMappingURL=humanizeReasoningLevel.d.ts.map

package/dist/app/humanizeReasoningLevel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"humanizeReasoningLevel.d.ts","sourceRoot":"","sources":["../../sources/app/humanizeReasoningLevel.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA4B5D"}

package/dist/app/humanizeReasoningLevel.js

@@ -0,0 +1,28 @@
+export function humanizeReasoningLevel(level) {
+    if (level === "off") {
+        return "Off";
+    }
+    if (level === "minimal") {
+        return "Minimal";
+    }
+    if (level === "low") {
+        return "Low";
+    }
+    if (level === "medium") {
+        return "Medium";
+    }
+    if (level === "high") {
+        return "High";
+    }
+    if (level === "xhigh") {
+        return "Extra High";
+    }
+    if (level === "max") {
+        return "Maximum";
+    }
+    return level
+        .split(/[-_\s]+/u)
+        .filter((part) => part.length > 0)
+        .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+        .join(" ");
+}

package/dist/app/index.d.ts

@@ -0,0 +1,17 @@
+export { CodingAssistantApp } from "./CodingAssistantApp.js";
+export type { CodingAssistantAgentBackend, CodingAssistantModelChoice, } from "./CodingAssistantAgentBackend.js";
+export type { CodingAssistantAppOptions, DefaultModelPreference } from "./CodingAssistantApp.js";
+export type { AppTranscriptEntry, AppTranscriptRole } from "./AppTranscriptEntry.js";
+export type { CodingAssistantRuntime } from "./CodingAssistantRuntime.js";
+export { createCodingAssistantAgent } from "./createCodingAssistantAgent.js";
+export type { CreateCodingAssistantAgentOptions } from "./createCodingAssistantAgent.js";
+export { createDefaultInstructions } from "./createDefaultInstructions.js";
+export { isMainModule } from "./isMainModule.js";
+export { main } from "./main.js";
+export { runDaemonCommand } from "./runDaemonCommand.js";
+export { runMonit } from "./runMonit.js";
+export { runApp } from "./runApp.js";
+export type { DaemonCommand } from "./runDaemonCommand.js";
+export type { RunMonitOptions } from "./runMonit.js";
+export type { RunAppOptions } from "./runApp.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/app/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../sources/app/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EACR,2BAA2B,EAC3B,0BAA0B,GAC7B,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjG,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACrF,YAAY,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC7E,YAAY,EAAE,iCAAiC,EAAE,MAAM,iCAAiC,CAAC;AACzF,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}

package/dist/app/index.js

@@ -0,0 +1,8 @@
+export { CodingAssistantApp } from "./CodingAssistantApp.js";
+export { createCodingAssistantAgent } from "./createCodingAssistantAgent.js";
+export { createDefaultInstructions } from "./createDefaultInstructions.js";
+export { isMainModule } from "./isMainModule.js";
+export { main } from "./main.js";
+export { runDaemonCommand } from "./runDaemonCommand.js";
+export { runMonit } from "./runMonit.js";
+export { runApp } from "./runApp.js";

package/dist/app/isMainModule.d.ts

@@ -0,0 +1,2 @@
+export declare function isMainModule(metaUrl: string, argv?: readonly string[]): boolean;
+//# sourceMappingURL=isMainModule.d.ts.map

package/dist/app/isMainModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isMainModule.d.ts","sourceRoot":"","sources":["../../sources/app/isMainModule.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,SAAS,MAAM,EAAiB,GAAG,OAAO,CAG7F"}

package/dist/app/isMainModule.js

@@ -0,0 +1,6 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+export function isMainModule(metaUrl, argv = process.argv) {
+    const entry = argv[1];
+    return entry !== undefined && metaUrl === pathToFileURL(resolve(entry)).href;
+}

package/dist/app/main.d.ts

@@ -0,0 +1,2 @@
+export declare function main(argv?: readonly string[]): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

package/dist/app/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../sources/app/main.ts"],"names":[],"mappings":"AAOA,wBAAsB,IAAI,CAAC,IAAI,GAAE,SAAS,MAAM,EAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CA0DzF"}

package/dist/app/main.js

@@ -0,0 +1,64 @@
+import { runDaemonCommand } from "./runDaemonCommand.js";
+import { runApp } from "./runApp.js";
+import { runMonit } from "./runMonit.js";
+import { runWebCommand } from "./runWebCommand.js";
+import { runWebServer } from "./web/runWebServer.js";
+import { runLocalProtocolServer } from "../server/index.js";
+export async function main(argv = process.argv.slice(2)) {
+    if (argv.includes("--web-server")) {
+        await runWebServer();
+        return;
+    }
+    if (argv.includes("--server")) {
+        await runLocalProtocolServer({
+            ...(process.env.RIG_SERVER_SOCKET_PATH !== undefined
+                ? { socketPath: process.env.RIG_SERVER_SOCKET_PATH }
+                : {}),
+            ...(process.env.RIG_SERVER_TOKEN_PATH !== undefined
+                ? { tokenPath: process.env.RIG_SERVER_TOKEN_PATH }
+                : {}),
+        });
+        return;
+    }
+    const options = {
+        cwd: process.cwd(),
+    };
+    const [command, sessionId] = argv;
+    if (command === "resume") {
+        if (sessionId === undefined || sessionId.length === 0) {
+            throw new Error("Usage: rig resume <session-id>");
+        }
+        options.resumeSessionId = sessionId;
+    }
+    if (command === "daemon") {
+        if (!isDaemonCommand(sessionId)) {
+            throw new Error("Usage: rig daemon <start|stop|status>");
+        }
+        await runDaemonCommand(sessionId);
+        return;
+    }
+    if (command === "monit") {
+        await runMonit();
+        return;
+    }
+    if (command === "web") {
+        await runWebCommand();
+        return;
+    }
+    if (process.env.OPENAI_API_KEY !== undefined) {
+        options.apiKey = process.env.OPENAI_API_KEY;
+    }
+    if (process.env.RIG_EFFORT !== undefined) {
+        options.effort = process.env.RIG_EFFORT;
+    }
+    if (process.env.RIG_MODEL !== undefined) {
+        options.modelId = process.env.RIG_MODEL;
+    }
+    if (process.env.RIG_PROVIDER !== undefined) {
+        options.providerId = process.env.RIG_PROVIDER;
+    }
+    await runApp(options);
+}
+function isDaemonCommand(value) {
+    return value === "start" || value === "stop" || value === "status";
+}

package/dist/app/readClipboardImage.d.ts

@@ -0,0 +1,10 @@
+export interface ClipboardImage {
+    data: string;
+    mediaType: string;
+    path: string;
+}
+export interface ReadClipboardImageOptions {
+    outputDirectory?: string;
+}
+export declare function readClipboardImage(options?: ReadClipboardImageOptions): Promise<ClipboardImage | undefined>;
+//# sourceMappingURL=readClipboardImage.d.ts.map

package/dist/app/readClipboardImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readClipboardImage.d.ts","sourceRoot":"","sources":["../../sources/app/readClipboardImage.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,yBAAyB;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAiBD,wBAAsB,kBAAkB,CACpC,OAAO,GAAE,yBAA8B,GACxC,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAgBrC"}

package/dist/app/readClipboardImage.js

@@ -0,0 +1,134 @@
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const SUPPORTED_IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
+const DEFAULT_LIST_TIMEOUT_MS = 1_000;
+const DEFAULT_READ_TIMEOUT_MS = 3_000;
+const DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+export async function readClipboardImage(options = {}) {
+    const rawImage = process.platform === "linux" && isWaylandSession()
+        ? (readClipboardImageViaWlPaste() ?? readClipboardImageViaXclip())
+        : await readClipboardImageViaNativeClipboard();
+    if (rawImage === undefined) {
+        return undefined;
+    }
+    const path = writeClipboardImageFile(rawImage, options.outputDirectory);
+    return {
+        data: rawImage.bytes.toString("base64"),
+        mediaType: rawImage.mediaType,
+        path,
+    };
+}
+function readClipboardImageViaWlPaste() {
+    const list = runCommand("wl-paste", ["--list-types"], {
+        timeoutMs: DEFAULT_LIST_TIMEOUT_MS,
+    });
+    if (!list.ok) {
+        return undefined;
+    }
+    const selectedType = selectPreferredImageMimeType(lines(list.stdout));
+    if (selectedType === undefined) {
+        return undefined;
+    }
+    const data = runCommand("wl-paste", ["--type", selectedType, "--no-newline"]);
+    if (!data.ok || data.stdout.length === 0) {
+        return undefined;
+    }
+    return { bytes: data.stdout, mediaType: baseMimeType(selectedType) };
+}
+function readClipboardImageViaXclip() {
+    const targets = runCommand("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"], {
+        timeoutMs: DEFAULT_LIST_TIMEOUT_MS,
+    });
+    const preferred = targets.ok ? selectPreferredImageMimeType(lines(targets.stdout)) : undefined;
+    const tryTypes = preferred === undefined
+        ? [...SUPPORTED_IMAGE_MIME_TYPES]
+        : [preferred, ...SUPPORTED_IMAGE_MIME_TYPES];
+    for (const mimeType of tryTypes) {
+        const data = runCommand("xclip", ["-selection", "clipboard", "-t", mimeType, "-o"]);
+        if (data.ok && data.stdout.length > 0) {
+            return { bytes: data.stdout, mediaType: baseMimeType(mimeType) };
+        }
+    }
+    return undefined;
+}
+async function readClipboardImageViaNativeClipboard() {
+    const clipboard = loadClipboardModule();
+    if (clipboard === undefined || !clipboard.hasImage()) {
+        return undefined;
+    }
+    const imageData = await clipboard.getImageBinary();
+    if (imageData.length === 0) {
+        return undefined;
+    }
+    return { bytes: Buffer.from(imageData), mediaType: "image/png" };
+}
+function loadClipboardModule() {
+    try {
+        const require = createRequire(import.meta.url);
+        return require("@mariozechner/clipboard");
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeClipboardImageFile(image, outputDirectory) {
+    const directory = outputDirectory ?? join(tmpdir(), "rig-clipboard-images");
+    mkdirSync(directory, { recursive: true });
+    const path = join(directory, `rig-clipboard-${randomUUID()}.${extensionForMimeType(image.mediaType)}`);
+    writeFileSync(path, image.bytes);
+    return path;
+}
+function extensionForMimeType(mimeType) {
+    switch (baseMimeType(mimeType)) {
+        case "image/jpeg":
+            return "jpg";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        default:
+            return "png";
+    }
+}
+function selectPreferredImageMimeType(mimeTypes) {
+    const normalized = mimeTypes
+        .map((type) => ({ base: baseMimeType(type), raw: type.trim() }))
+        .filter((type) => type.raw.length > 0);
+    for (const preferred of SUPPORTED_IMAGE_MIME_TYPES) {
+        const match = normalized.find((type) => type.base === preferred);
+        if (match !== undefined) {
+            return match.raw;
+        }
+    }
+    return normalized.find((type) => type.base.startsWith("image/"))?.raw;
+}
+function baseMimeType(mimeType) {
+    return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+function isWaylandSession() {
+    return Boolean(process.env.WAYLAND_DISPLAY) || process.env.XDG_SESSION_TYPE === "wayland";
+}
+function lines(buffer) {
+    return buffer
+        .toString("utf8")
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function runCommand(command, args, options = {}) {
+    const result = spawnSync(command, [...args], {
+        maxBuffer: options.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES,
+        timeout: options.timeoutMs ?? DEFAULT_READ_TIMEOUT_MS,
+    });
+    if (result.error !== undefined || result.status !== 0) {
+        return { ok: false, stdout: Buffer.alloc(0) };
+    }
+    return {
+        ok: true,
+        stdout: Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.from(result.stdout ?? ""),
+    };
+}

package/dist/app/readPackageVersion.d.ts

@@ -0,0 +1,2 @@
+export declare function readPackageVersion(): string;
+//# sourceMappingURL=readPackageVersion.d.ts.map

package/dist/app/readPackageVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readPackageVersion.d.ts","sourceRoot":"","sources":["../../sources/app/readPackageVersion.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,IAAI,MAAM,CAQ3C"}

package/dist/app/readPackageVersion.js

@@ -0,0 +1,11 @@
+import { readFileSync } from "node:fs";
+export function readPackageVersion() {
+    try {
+        const contents = readFileSync(new URL("../../package.json", import.meta.url), "utf8");
+        const manifest = JSON.parse(contents);
+        return typeof manifest.version === "string" ? manifest.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}

package/dist/app/renderActivityWave.d.ts

@@ -0,0 +1,3 @@
+export declare const ACTIVITY_WAVE_FRAME_COUNT = 12;
+export declare function renderActivityWave(text: string, frame: number): string;
+//# sourceMappingURL=renderActivityWave.d.ts.map

package/dist/app/renderActivityWave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderActivityWave.d.ts","sourceRoot":"","sources":["../../sources/app/renderActivityWave.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAUtE"}

package/dist/app/renderActivityWave.js

@@ -0,0 +1,28 @@
+const RESET = "\x1b[0m";
+export const ACTIVITY_WAVE_FRAME_COUNT = 12;
+export function renderActivityWave(text, frame) {
+    return `${Array.from(text)
+        .map((character, index) => {
+        if (character === " ") {
+            return character;
+        }
+        return `\x1b[38;5;${activityWaveColor(index, frame)}m${character}`;
+    })
+        .join("")}${RESET}`;
+}
+function activityWaveColor(index, frame) {
+    const phase = positiveModulo(index - frame, ACTIVITY_WAVE_FRAME_COUNT);
+    const distance = Math.min(phase, ACTIVITY_WAVE_FRAME_COUNT - phase);
+    if (distance === 0)
+        return 255;
+    if (distance === 1)
+        return 253;
+    if (distance === 2)
+        return 250;
+    if (distance === 3)
+        return 247;
+    return 244;
+}
+function positiveModulo(value, modulus) {
+    return ((value % modulus) + modulus) % modulus;
+}

package/dist/app/renderAgentMarkdown.d.ts

@@ -0,0 +1,7 @@
+export interface RenderAgentMarkdownOptions {
+    text: string;
+    width: number;
+    cwd: string;
+}
+export declare function renderAgentMarkdown(options: RenderAgentMarkdownOptions): string[];
+//# sourceMappingURL=renderAgentMarkdown.d.ts.map

package/dist/app/renderAgentMarkdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderAgentMarkdown.d.ts","sourceRoot":"","sources":["../../sources/app/renderAgentMarkdown.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,0BAA0B;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,MAAM,EAAE,CAmBjF"}

package/dist/app/renderAgentMarkdown.js

@@ -0,0 +1,23 @@
+import { Markdown, truncateToWidth } from "@earendil-works/pi-tui";
+import { createAgentMarkdownTheme } from "./createAgentMarkdownTheme.js";
+const RESET = "\x1b[0m";
+const TEXT_FG = "\x1b[38;5;252m";
+const DEFAULT_TEXT_STYLE = {
+    color: (text) => `${TEXT_FG}${text}${RESET}`,
+};
+export function renderAgentMarkdown(options) {
+    const width = Math.max(1, options.width);
+    const text = options.text.trimEnd();
+    if (text.length === 0) {
+        return [" ".repeat(width)];
+    }
+    const markdown = new Markdown(text, 0, 0, createAgentMarkdownTheme(), DEFAULT_TEXT_STYLE, {
+        preserveBackslashEscapes: true,
+        preserveOrderedListMarkers: true,
+    });
+    const rendered = markdown.render(width);
+    if (rendered.length === 0) {
+        return [" ".repeat(width)];
+    }
+    return rendered.map((line) => truncateToWidth(line, width, "", true));
+}

package/dist/app/resolvePortlessCliPath.d.ts

@@ -0,0 +1,2 @@
+export declare function resolvePortlessCliPath(): Promise<string>;
+//# sourceMappingURL=resolvePortlessCliPath.d.ts.map

package/dist/app/resolvePortlessCliPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePortlessCliPath.d.ts","sourceRoot":"","sources":["../../sources/app/resolvePortlessCliPath.ts"],"names":[],"mappings":"AAMA,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,CAW9D"}

package/dist/app/resolvePortlessCliPath.js

@@ -0,0 +1,31 @@
+import { access, readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+const require = createRequire(import.meta.url);
+export async function resolvePortlessCliPath() {
+    const searchPaths = require.resolve.paths("portless") ?? [];
+    for (const searchPath of searchPaths) {
+        const packageRoot = join(searchPath, "portless");
+        const cliPath = await readPackageCliPath(packageRoot);
+        if (cliPath !== undefined) {
+            return cliPath;
+        }
+    }
+    throw new Error("Cannot locate the Portless CLI.");
+}
+async function readPackageCliPath(packageRoot) {
+    try {
+        const packageJsonPath = join(packageRoot, "package.json");
+        const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+        const binPath = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.portless;
+        if (binPath === undefined || binPath.length === 0) {
+            return undefined;
+        }
+        const cliPath = resolve(packageRoot, binPath);
+        await access(cliPath);
+        return cliPath;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/app/runApp.d.ts

@@ -0,0 +1,12 @@
+export interface RunAppOptions {
+    apiKey?: string;
+    cwd?: string;
+    effort?: string;
+    instructions?: string;
+    modelId?: string;
+    providerId?: string;
+    resumeSessionId?: string;
+    showReasoning?: boolean;
+}
+export declare function runApp(options?: RunAppOptions): Promise<void>;
+//# sourceMappingURL=runApp.d.ts.map

package/dist/app/runApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runApp.d.ts","sourceRoot":"","sources":["../../sources/app/runApp.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,aAAa;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,wBAAsB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoJvE"}