mono-pilot 0.2.10 → 0.2.13

package/dist/src/tools/generate-image.js

@@ -0,0 +1,567 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { extname } from "node:path";
+import { Text } from "@mariozechner/pi-tui";
+import { keyHint } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { loadMonoPilotConfigObject } from "../config/mono-pilot.js";
+import { extractImageGenConfig } from "../config/image-gen.js";
+const DESCRIPTION = `Generate images using the Google Gemini API or OpenRouter (default model \`gemini-3.1-flash-image-preview\`).
+
+Use when you need to create or edit an image from a text prompt. Optionally provide an input image for edits.
+
+Requirements:
+- Provider \`gemini\`: set an API key in \`~/.mono-pilot/config.json\`.
+- Provider \`openrouter\`: set an API key in \`~/.mono-pilot/config.json\`.
+- Default provider/model can be set in \`~/.mono-pilot/config.json\` under \`imageGen\`.
+
+Inputs:
+- \`prompt\` is required.
+- \`image_path\` or \`image_base64\` (with \`image_mime_type\`) are optional for image editing.
+- \`output_path\` is optional to save the first generated image.
+
+Outputs:
+- Returns text parts (if any) and one or more image parts.
+- Image parts use \`ImageContent\` format: { "type": "image", "data": "<base64>", "mimeType": "image/png" }.`;
+const DEFAULT_MODEL = "gemini-3.1-flash-image-preview";
+const DEFAULT_OPENROUTER_MODEL = "google/gemini-3.1-flash-image-preview";
+const REQUEST_TIMEOUT_MS = 60_000;
+const generateImageSchema = Type.Object({
+    prompt: Type.String({
+        description: "Text prompt used to generate or edit the image.",
+    }),
+    image_path: Type.Optional(Type.String({
+        description: "Optional path to an input image for editing.",
+    })),
+    image_base64: Type.Optional(Type.String({
+        description: "Optional base64-encoded input image data.",
+    })),
+    image_mime_type: Type.Optional(Type.String({
+        description: "MIME type for image_base64 (e.g., image/png).",
+    })),
+    output_path: Type.Optional(Type.String({
+        description: "Optional output path to save the first generated image.",
+    })),
+});
+function normalizeProvider(value) {
+    return value === "openrouter" ? "openrouter" : "gemini";
+}
+function normalizePrompt(prompt) {
+    return prompt.trim();
+}
+function detectMimeType(path) {
+    const ext = extname(path).toLowerCase();
+    if (ext === ".png")
+        return "image/png";
+    if (ext === ".jpg" || ext === ".jpeg")
+        return "image/jpeg";
+    if (ext === ".gif")
+        return "image/gif";
+    if (ext === ".webp")
+        return "image/webp";
+    return undefined;
+}
+function collectInputImageInfo(params) {
+    if (params.image_path) {
+        return { ref: params.image_path, source: "path" };
+    }
+    if (params.image_base64) {
+        const mimeType = params.image_mime_type;
+        const ref = mimeType
+            ? `data:${mimeType};base64,${params.image_base64}`
+            : params.image_base64;
+        return { ref, source: "base64", mimeType };
+    }
+    return {};
+}
+function buildParts(params) {
+    const parts = [];
+    if (params.image_path) {
+        const buffer = readFileSync(params.image_path);
+        const mimeType = detectMimeType(params.image_path);
+        if (!mimeType) {
+            throw new Error("Unsupported image_path extension. Use png/jpg/gif/webp.");
+        }
+        parts.push({
+            inlineData: {
+                mimeType,
+                data: buffer.toString("base64"),
+            },
+        });
+    }
+    if (params.image_base64) {
+        if (!params.image_mime_type) {
+            throw new Error("image_mime_type is required when image_base64 is provided.");
+        }
+        parts.push({
+            inlineData: {
+                mimeType: params.image_mime_type,
+                data: params.image_base64,
+            },
+        });
+    }
+    parts.push({ text: normalizePrompt(params.prompt) });
+    return { parts, usedInput: Boolean(params.image_path || params.image_base64) };
+}
+function collectResponseParts(parts) {
+    const content = [];
+    let imageCount = 0;
+    let textCount = 0;
+    for (const part of parts) {
+        const text = typeof part.text === "string" ? part.text : undefined;
+        const inlineData = (typeof part.inlineData === "object" && part.inlineData !== null && part.inlineData) ||
+            (typeof part.inline_data === "object" && part.inline_data !== null && part.inline_data);
+        if (text) {
+            content.push({ type: "text", text });
+            textCount += 1;
+            continue;
+        }
+        if (inlineData && typeof inlineData === "object") {
+            const data = inlineData.data;
+            const mimeType = inlineData.mimeType ?? inlineData.mime_type;
+            if (typeof data === "string" && typeof mimeType === "string") {
+                content.push({ type: "image", data, mimeType });
+                imageCount += 1;
+            }
+        }
+    }
+    return { content, imageCount, textCount };
+}
+function parseDataUrl(url) {
+    if (!url.startsWith("data:")) {
+        return null;
+    }
+    const match = url.match(/^data:([^;]+);base64,(.*)$/);
+    if (!match) {
+        return null;
+    }
+    return { mimeType: match[1], data: match[2] };
+}
+function collectOpenRouterParts(message) {
+    const content = [];
+    let imageCount = 0;
+    let textCount = 0;
+    const messageContent = message.content;
+    const text = typeof messageContent === "string" ? messageContent : undefined;
+    if (text) {
+        content.push({ type: "text", text });
+        textCount += 1;
+    }
+    if (Array.isArray(messageContent)) {
+        for (const part of messageContent) {
+            if (!part || typeof part !== "object") {
+                continue;
+            }
+            const partType = part.type;
+            if (partType === "text" && typeof part.text === "string") {
+                content.push({ type: "text", text: part.text });
+                textCount += 1;
+                continue;
+            }
+            if (partType === "image_url") {
+                const imageUrl = (typeof part.image_url === "object" &&
+                    part.image_url !== null
+                    ? part.image_url.url
+                    : undefined) ??
+                    (typeof part.url === "string" ? part.url : undefined);
+                if (typeof imageUrl !== "string") {
+                    continue;
+                }
+                const parsed = parseDataUrl(imageUrl);
+                if (parsed) {
+                    content.push({ type: "image", data: parsed.data, mimeType: parsed.mimeType });
+                    imageCount += 1;
+                    continue;
+                }
+                content.push({ type: "text", text: `OpenRouter image URL: ${imageUrl}` });
+                textCount += 1;
+            }
+        }
+    }
+    const images = Array.isArray(message.images) ? message.images : [];
+    for (const image of images) {
+        const imageUrl = (typeof image.image_url === "object" && image.image_url !== null
+            ? image.image_url.url
+            : undefined) ??
+            (typeof image.url === "string" ? image.url : undefined);
+        if (typeof imageUrl !== "string") {
+            continue;
+        }
+        const parsed = parseDataUrl(imageUrl);
+        if (parsed) {
+            content.push({ type: "image", data: parsed.data, mimeType: parsed.mimeType });
+            imageCount += 1;
+            continue;
+        }
+        content.push({ type: "text", text: `OpenRouter image URL: ${imageUrl}` });
+        textCount += 1;
+    }
+    return { content, imageCount, textCount };
+}
+function findFirstImage(content) {
+    return content.find((entry) => entry.type === "image");
+}
+function buildOpenRouterMessages(prompt, parts, usedInput) {
+    if (!usedInput) {
+        return [{ role: "user", content: prompt }];
+    }
+    const content = parts.map((part) => {
+        if ("inlineData" in part && typeof part.inlineData === "object" && part.inlineData) {
+            const inlineData = part.inlineData;
+            if (typeof inlineData.mimeType === "string" && typeof inlineData.data === "string") {
+                return {
+                    type: "image_url",
+                    image_url: {
+                        url: `data:${inlineData.mimeType};base64,${inlineData.data}`,
+                    },
+                };
+            }
+        }
+        if ("text" in part && typeof part.text === "string") {
+            return { type: "text", text: part.text };
+        }
+        return { type: "text", text: JSON.stringify(part) };
+    });
+    return [{ role: "user", content }];
+}
+function resolveOpenRouterEndpoint(baseUrl) {
+    const fallback = "https://openrouter.ai/api/v1/chat/completions";
+    if (!baseUrl)
+        return fallback;
+    const trimmed = baseUrl.trim();
+    if (!trimmed)
+        return fallback;
+    const normalized = trimmed.replace(/\/+$/, "");
+    if (normalized.endsWith("/chat/completions")) {
+        return normalized;
+    }
+    return `${normalized}/chat/completions`;
+}
+function chunkText(text, size) {
+    if (text.length <= size)
+        return [text];
+    const chunks = [];
+    for (let i = 0; i < text.length; i += size) {
+        chunks.push(text.slice(i, i + size));
+    }
+    return chunks;
+}
+function buildResponseTextParts(payload, chunkSize = 1800) {
+    const json = JSON.stringify(payload, null, 2);
+    return chunkText(json, chunkSize).map((text) => ({ type: "text", text }));
+}
+export default function generateImageExtension(pi) {
+    // System prompt injection is handled centrally by system-prompt extension.
+    pi.registerTool({
+        name: "GenerateImage",
+        label: "GenerateImage",
+        description: DESCRIPTION,
+        parameters: generateImageSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const prompt = typeof input.prompt === "string" ? input.prompt.trim() : "";
+            const displayPrompt = prompt.length > 80 ? `${prompt.slice(0, 79)}…` : prompt || "(missing prompt)";
+            let text = theme.fg("toolTitle", theme.bold("GenerateImage"));
+            text += ` ${theme.fg("toolOutput", displayPrompt)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Generating image..."), 0, 0);
+            }
+            const details = (result.details ?? {});
+            const textBlocks = result.content.filter((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!expanded) {
+                if (details.output_image_written && details.output_image_path) {
+                    const summary = `saved: ${details.output_image_path}`;
+                    return new Text(theme.fg("muted", `${summary} (click or ${keyHint("expandTools", "to expand")})`), 0, 0);
+                }
+                const imageCount = result.content.filter((entry) => entry.type === "image").length;
+                const summary = `${imageCount} image${imageCount === 1 ? "" : "s"}`;
+                return new Text(theme.fg("muted", `${summary} (click or ${keyHint("expandTools", "to expand")})`), 0, 0);
+            }
+            const lines = [];
+            for (const block of textBlocks) {
+                lines.push(...block.text.split("\n"));
+            }
+            if (details.prompt) {
+                lines.push(theme.fg("muted", `prompt: ${details.prompt}`));
+            }
+            if (details.input_image_ref) {
+                lines.push(theme.fg("muted", `input image: ${details.input_image_ref}`));
+            }
+            if (details.output_image_path) {
+                const suffix = details.output_image_written === false ? " (failed)" : "";
+                lines.push(theme.fg("muted", `output image: ${details.output_image_path}${suffix}`));
+            }
+            if (details.provider) {
+                lines.push(theme.fg("muted", `provider: ${details.provider}`));
+            }
+            lines.push(theme.fg("muted", `(click or ${keyHint("expandTools", "to collapse")})`));
+            return new Text(lines.join("\n"), 0, 0);
+        },
+        async execute(_toolCallId, params, signal) {
+            const normalizedPrompt = normalizePrompt(params.prompt ?? "");
+            const inputImageInfo = collectInputImageInfo(params);
+            const baseDetails = {
+                prompt: normalizedPrompt || undefined,
+                input_image_ref: inputImageInfo.ref,
+                input_image_source: inputImageInfo.source,
+                input_image_mime_type: inputImageInfo.mimeType,
+                output_image_path: params.output_path,
+            };
+            let config = {};
+            try {
+                config = await loadMonoPilotConfigObject();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const fallbackProvider = "gemini";
+                return {
+                    content: [{ type: "text", text: `GenerateImage error: ${message}` }],
+                    details: {
+                        provider: fallbackProvider,
+                        model: DEFAULT_MODEL,
+                        ...baseDetails,
+                        error: message,
+                        api_key_source: "missing",
+                    },
+                };
+            }
+            const imageGenConfig = extractImageGenConfig(config);
+            const provider = normalizeProvider(imageGenConfig.selection.provider);
+            const providerConfig = imageGenConfig.providers[provider];
+            const apiKeyFromConfig = providerConfig?.apiKey?.trim();
+            const apiKey = apiKeyFromConfig;
+            const apiKeySource = apiKeyFromConfig ? "config" : "missing";
+            const model = imageGenConfig.selection.model?.trim() ||
+                providerConfig?.models?.[0]?.id ||
+                (provider === "openrouter" ? DEFAULT_OPENROUTER_MODEL : DEFAULT_MODEL);
+            const apiKeyInfo = {
+                provider,
+                api_key: apiKey ?? "",
+                api_key_source: apiKeySource,
+            };
+            if (!apiKey) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "GenerateImage error: missing API key. Provide api_key or set it in ~/.mono-pilot/config.json.",
+                        },
+                    ],
+                    details: {
+                        model,
+                        ...baseDetails,
+                        error: "missing api key",
+                        ...apiKeyInfo,
+                    },
+                };
+            }
+            if (params.image_path && params.image_base64) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "GenerateImage error: provide only one of image_path or image_base64.",
+                        },
+                    ],
+                    details: {
+                        model,
+                        ...baseDetails,
+                        error: "invalid input",
+                        ...apiKeyInfo,
+                    },
+                };
+            }
+            const prompt = normalizedPrompt;
+            if (prompt.length === 0) {
+                return {
+                    content: [{ type: "text", text: "GenerateImage error: prompt cannot be empty." }],
+                    details: {
+                        model,
+                        ...baseDetails,
+                        error: "empty prompt",
+                        ...apiKeyInfo,
+                    },
+                };
+            }
+            let parts = [];
+            let usedInput = false;
+            try {
+                const built = buildParts(params);
+                parts = built.parts;
+                usedInput = built.usedInput;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: "text", text: `GenerateImage error: ${message}` }],
+                    details: {
+                        model,
+                        ...baseDetails,
+                        error: message,
+                        ...apiKeyInfo,
+                    },
+                };
+            }
+            const openRouterMessages = buildOpenRouterMessages(prompt, parts, usedInput);
+            const openRouterBaseUrl = provider === "openrouter" ? resolveOpenRouterEndpoint(providerConfig?.baseUrl) : "";
+            const useAuthHeader = providerConfig?.authHeader !== false;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+            const onAbort = () => controller.abort();
+            signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                const response = provider === "openrouter"
+                    ? await fetch(openRouterBaseUrl, {
+                        method: "POST",
+                        headers: {
+                            ...(useAuthHeader ? { Authorization: `Bearer ${apiKey}` } : { "x-api-key": apiKey }),
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            model,
+                            messages: openRouterMessages,
+                            modalities: ["image", "text"],
+                        }),
+                        signal: controller.signal,
+                    })
+                    : await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {
+                        method: "POST",
+                        headers: {
+                            "x-goog-api-key": apiKey,
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            contents: [{ parts }],
+                            generationConfig: {
+                                responseModalities: ["TEXT", "IMAGE"],
+                            },
+                        }),
+                        signal: controller.signal,
+                    });
+                const payload = (await response.json());
+                if (!response.ok) {
+                    const errorMessage = (typeof payload.error === "object" && payload.error !== null && "message" in payload.error
+                        ? String(payload.error.message ?? "")
+                        : "") || JSON.stringify(payload);
+                    const responseParts = buildResponseTextParts(payload);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `GenerateImage error: HTTP ${response.status} ${response.statusText}\n${errorMessage}`,
+                            },
+                            ...responseParts,
+                        ],
+                        details: {
+                            model,
+                            ...baseDetails,
+                            response: JSON.stringify(payload),
+                            error: JSON.stringify(payload),
+                            ...apiKeyInfo,
+                        },
+                    };
+                }
+                const candidates = Array.isArray(payload.candidates) ? payload.candidates : [];
+                const firstCandidate = candidates[0];
+                const openRouterChoices = Array.isArray(payload.choices) ? payload.choices : [];
+                const openRouterMessageRaw = openRouterChoices[0]?.message ?? {};
+                const openRouterMessage = typeof openRouterMessageRaw === "object" && openRouterMessageRaw !== null
+                    ? openRouterMessageRaw
+                    : {};
+                const collected = provider === "openrouter"
+                    ? collectOpenRouterParts(openRouterMessage)
+                    : collectResponseParts(Array.isArray(firstCandidate?.content?.parts)
+                        ? (firstCandidate?.content ?? {}).parts
+                        : []);
+                if (collected.content.length === 0) {
+                    const responseParts = buildResponseTextParts(payload);
+                    return {
+                        content: [
+                            { type: "text", text: "GenerateImage: no image data returned." },
+                            ...responseParts,
+                        ],
+                        details: {
+                            model,
+                            ...baseDetails,
+                            image_count: 0,
+                            text_count: 0,
+                            used_input_image: usedInput || undefined,
+                            response: JSON.stringify(payload),
+                            ...apiKeyInfo,
+                        },
+                    };
+                }
+                let outputWritten;
+                if (params.output_path) {
+                    const image = findFirstImage(collected.content);
+                    if (image) {
+                        try {
+                            writeFileSync(params.output_path, Buffer.from(image.data, "base64"));
+                            outputWritten = true;
+                        }
+                        catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            return {
+                                content: [{ type: "text", text: `GenerateImage error: ${message}` }, ...collected.content],
+                                details: {
+                                    model,
+                                    ...baseDetails,
+                                    output_image_written: false,
+                                    image_count: collected.imageCount,
+                                    text_count: collected.textCount,
+                                    used_input_image: usedInput || undefined,
+                                    response: JSON.stringify(payload),
+                                    error: message,
+                                    ...apiKeyInfo,
+                                },
+                            };
+                        }
+                    }
+                    else {
+                        outputWritten = false;
+                    }
+                }
+                const outputContent = outputWritten && params.output_path
+                    ? [
+                        { type: "text", text: `GenerateImage saved: ${params.output_path}` },
+                        ...collected.content.filter((entry) => entry.type === "text"),
+                    ]
+                    : collected.content;
+                return {
+                    content: outputContent,
+                    details: {
+                        model,
+                        ...baseDetails,
+                        output_image_written: outputWritten,
+                        image_count: collected.imageCount,
+                        text_count: collected.textCount,
+                        used_input_image: usedInput || undefined,
+                        response: JSON.stringify(payload),
+                        ...apiKeyInfo,
+                    },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const timeoutMessage = controller.signal.aborted
+                    ? `GenerateImage error: request timed out after ${REQUEST_TIMEOUT_MS}ms.`
+                    : `GenerateImage error: ${message}`;
+                return {
+                    content: [{ type: "text", text: timeoutMessage }],
+                    details: {
+                        model,
+                        ...baseDetails,
+                        error: message,
+                        ...apiKeyInfo,
+                    },
+                };
+            }
+            finally {
+                clearTimeout(timeoutId);
+                signal?.removeEventListener("abort", onAbort);
+            }
+        },
+    });
+}

package/dist/{tools → src/tools}/glob.js

@@ -1,6 +1,7 @@
 import { existsSync, statSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, } from "@mariozechner/pi-coding-agent";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, keyHint, truncateHead, } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { globSync } from "glob";
 const DESCRIPTION = `
@@ -11,6 +12,8 @@ Tool to search for files matching a glob pattern
 - Use this tool when you need to find files by name patterns
 - You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches that are potentially useful as a batch.
 `.trim();
+const MAX_RENDER_PATH_CHARS = 120;
+const MAX_RENDER_PATTERN_CHARS = 160;
 const globSchema = Type.Object({
     target_directory: Type.Optional(Type.String({
         description: "Absolute path to directory to search for files in. If not provided, defaults to mono-pilot workspace root.",
@@ -25,6 +28,19 @@ Examples:
 - "**/test/**/test_*.ts" - find all test_*.ts files in any test directory`,
     }),
 });
+function compactForCommandArg(value, maxLength) {
+    const normalized = value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\\n").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+function shellQuoteArg(value) {
+    if (value.length === 0)
+        return "''";
+    if (/^[A-Za-z0-9_./:=,+-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, `"'"'`)}'`;
+}
 function normalizeGlobPattern(pattern) {
     const trimmed = pattern.trim();
     if (trimmed.length === 0) {
@@ -84,6 +100,44 @@ export default function (pi) {
         label: "Glob",
         description: DESCRIPTION,
         parameters: globSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const pattern = typeof input.glob_pattern === "string" && input.glob_pattern.trim().length > 0
+                ? compactForCommandArg(input.glob_pattern, MAX_RENDER_PATTERN_CHARS)
+                : "(missing glob_pattern)";
+            const targetDirectory = typeof input.target_directory === "string" && input.target_directory.trim().length > 0
+                ? compactForCommandArg(input.target_directory, MAX_RENDER_PATH_CHARS)
+                : undefined;
+            const commandArgs = [pattern];
+            if (targetDirectory)
+                commandArgs.push("--target-directory", targetDirectory);
+            const commandText = commandArgs.map(shellQuoteArg).join(" ");
+            let text = theme.fg("toolTitle", theme.bold("Glob"));
+            text += ` ${theme.fg("toolOutput", commandText)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Searching..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock || typeof textBlock.text !== "string") {
+                return new Text(theme.fg("error", "No text result returned."), 0, 0);
+            }
+            const fullText = textBlock.text;
+            const details = result.details;
+            const fileCount = details?.returned_matches ?? fullText.split("\n").length;
+            if (!expanded) {
+                const summary = `${fileCount} files (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = fullText
+                .split("\n")
+                .map((line) => theme.fg("toolOutput", line))
+                .join("\n");
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
+            return new Text(text, 0, 0);
+        },
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const targetDirectory = resolveTargetDirectory(params.target_directory, ctx.cwd);
             const normalizedPattern = normalizeGlobPattern(params.glob_pattern);