indusagi-coding-agent 0.1.0

package/dist/utils/clipboard.js

@@ -0,0 +1,58 @@
+import { execSync, spawn } from "child_process";
+import { platform } from "os";
+import { isWaylandSession } from "./clipboard-image.js";
+export function copyToClipboard(text) {
+    const p = platform();
+    const options = { input: text, timeout: 5000 };
+    try {
+        if (p === "darwin") {
+            execSync("pbcopy", options);
+        }
+        else if (p === "win32") {
+            execSync("clip", options);
+        }
+        else {
+            // Linux - try wl-copy for Wayland, fall back to xclip/xsel for X11
+            const isWayland = isWaylandSession();
+            if (isWayland) {
+                try {
+                    // Verify wl-copy exists (spawn errors are async and won't be caught)
+                    execSync("which wl-copy", { stdio: "ignore" });
+                    // wl-copy with execSync hangs due to fork behavior; use spawn instead
+                    const proc = spawn("wl-copy", [], { stdio: ["pipe", "ignore", "ignore"] });
+                    proc.stdin.on("error", () => {
+                        // Ignore EPIPE errors if wl-copy exits early
+                    });
+                    proc.stdin.write(text);
+                    proc.stdin.end();
+                    proc.unref();
+                }
+                catch {
+                    // Fall back to xclip/xsel (works on XWayland)
+                    try {
+                        execSync("xclip -selection clipboard", options);
+                    }
+                    catch {
+                        execSync("xsel --clipboard --input", options);
+                    }
+                }
+            }
+            else {
+                try {
+                    execSync("xclip -selection clipboard", options);
+                }
+                catch {
+                    execSync("xsel --clipboard --input", options);
+                }
+            }
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (p === "linux") {
+            const tools = isWaylandSession() ? "wl-copy, xclip, or xsel" : "xclip or xsel";
+            throw new Error(`Failed to copy to clipboard. Install ${tools}: ${msg}`);
+        }
+        throw new Error(`Failed to copy to clipboard: ${msg}`);
+    }
+}

package/dist/utils/frontmatter.js

@@ -0,0 +1,25 @@
+import { parse } from "yaml";
+const normalizeNewlines = (value) => value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+const extractFrontmatter = (content) => {
+    const normalized = normalizeNewlines(content);
+    if (!normalized.startsWith("---")) {
+        return { yamlString: null, body: normalized };
+    }
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1) {
+        return { yamlString: null, body: normalized };
+    }
+    return {
+        yamlString: normalized.slice(4, endIndex),
+        body: normalized.slice(endIndex + 4).trim(),
+    };
+};
+export const parseFrontmatter = (content) => {
+    const { yamlString, body } = extractFrontmatter(content);
+    if (!yamlString) {
+        return { frontmatter: {}, body };
+    }
+    const parsed = parse(yamlString);
+    return { frontmatter: (parsed ?? {}), body };
+};
+export const stripFrontmatter = (content) => parseFrontmatter(content).body;

package/dist/utils/git.js

@@ -0,0 +1,5 @@
+const GIT_HOSTS = ["github.com", "gitlab.com", "bitbucket.org", "codeberg.org"];
+export function looksLikeGitUrl(source) {
+    const normalized = source.replace(/^https?:\/\//, "");
+    return GIT_HOSTS.some((host) => normalized.startsWith(`${host}/`));
+}

package/dist/utils/image-convert.js

@@ -0,0 +1,34 @@
+import { loadPhoton } from "./photon.js";
+/**
+ * Convert image to PNG format for terminal display.
+ * Kitty graphics protocol requires PNG format (f=100).
+ */
+export async function convertToPng(base64Data, mimeType) {
+    // Already PNG, no conversion needed
+    if (mimeType === "image/png") {
+        return { data: base64Data, mimeType };
+    }
+    const photon = await loadPhoton();
+    if (!photon) {
+        // Photon not available, can't convert
+        return null;
+    }
+    try {
+        const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
+        const image = photon.PhotonImage.new_from_byteslice(bytes);
+        try {
+            const pngBuffer = image.get_bytes();
+            return {
+                data: Buffer.from(pngBuffer).toString("base64"),
+                mimeType: "image/png",
+            };
+        }
+        finally {
+            image.free();
+        }
+    }
+    catch {
+        // Conversion failed
+        return null;
+    }
+}

package/dist/utils/image-resize.js

@@ -0,0 +1,180 @@
+import { loadPhoton } from "./photon.js";
+// 4.5MB - provides headroom below Anthropic's 5MB limit
+const DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
+const DEFAULT_OPTIONS = {
+    maxWidth: 2000,
+    maxHeight: 2000,
+    maxBytes: DEFAULT_MAX_BYTES,
+    jpegQuality: 80,
+};
+/** Helper to pick the smaller of two buffers */
+function pickSmaller(a, b) {
+    return a.buffer.length <= b.buffer.length ? a : b;
+}
+/**
+ * Resize an image to fit within the specified max dimensions and file size.
+ * Returns the original image if it already fits within the limits.
+ *
+ * Uses Photon (Rust/WASM) for image processing. If Photon is not available,
+ * returns the original image unchanged.
+ *
+ * Strategy for staying under maxBytes:
+ * 1. First resize to maxWidth/maxHeight
+ * 2. Try both PNG and JPEG formats, pick the smaller one
+ * 3. If still too large, try JPEG with decreasing quality
+ * 4. If still too large, progressively reduce dimensions
+ */
+export async function resizeImage(img, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const inputBuffer = Buffer.from(img.data, "base64");
+    const photon = await loadPhoton();
+    if (!photon) {
+        // Photon not available, return original image
+        return {
+            data: img.data,
+            mimeType: img.mimeType,
+            originalWidth: 0,
+            originalHeight: 0,
+            width: 0,
+            height: 0,
+            wasResized: false,
+        };
+    }
+    let image;
+    try {
+        image = photon.PhotonImage.new_from_byteslice(new Uint8Array(inputBuffer));
+        const originalWidth = image.get_width();
+        const originalHeight = image.get_height();
+        const format = img.mimeType?.split("/")[1] ?? "png";
+        // Check if already within all limits (dimensions AND size)
+        const originalSize = inputBuffer.length;
+        if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && originalSize <= opts.maxBytes) {
+            return {
+                data: img.data,
+                mimeType: img.mimeType ?? `image/${format}`,
+                originalWidth,
+                originalHeight,
+                width: originalWidth,
+                height: originalHeight,
+                wasResized: false,
+            };
+        }
+        // Calculate initial dimensions respecting max limits
+        let targetWidth = originalWidth;
+        let targetHeight = originalHeight;
+        if (targetWidth > opts.maxWidth) {
+            targetHeight = Math.round((targetHeight * opts.maxWidth) / targetWidth);
+            targetWidth = opts.maxWidth;
+        }
+        if (targetHeight > opts.maxHeight) {
+            targetWidth = Math.round((targetWidth * opts.maxHeight) / targetHeight);
+            targetHeight = opts.maxHeight;
+        }
+        // Helper to resize and encode in both formats, returning the smaller one
+        function tryBothFormats(width, height, jpegQuality) {
+            const resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
+            try {
+                const pngBuffer = resized.get_bytes();
+                const jpegBuffer = resized.get_bytes_jpeg(jpegQuality);
+                return pickSmaller({ buffer: pngBuffer, mimeType: "image/png" }, { buffer: jpegBuffer, mimeType: "image/jpeg" });
+            }
+            finally {
+                resized.free();
+            }
+        }
+        // Try to produce an image under maxBytes
+        const qualitySteps = [85, 70, 55, 40];
+        const scaleSteps = [1.0, 0.75, 0.5, 0.35, 0.25];
+        let best;
+        let finalWidth = targetWidth;
+        let finalHeight = targetHeight;
+        // First attempt: resize to target dimensions, try both formats
+        best = tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
+        if (best.buffer.length <= opts.maxBytes) {
+            return {
+                data: Buffer.from(best.buffer).toString("base64"),
+                mimeType: best.mimeType,
+                originalWidth,
+                originalHeight,
+                width: finalWidth,
+                height: finalHeight,
+                wasResized: true,
+            };
+        }
+        // Still too large - try JPEG with decreasing quality
+        for (const quality of qualitySteps) {
+            best = tryBothFormats(targetWidth, targetHeight, quality);
+            if (best.buffer.length <= opts.maxBytes) {
+                return {
+                    data: Buffer.from(best.buffer).toString("base64"),
+                    mimeType: best.mimeType,
+                    originalWidth,
+                    originalHeight,
+                    width: finalWidth,
+                    height: finalHeight,
+                    wasResized: true,
+                };
+            }
+        }
+        // Still too large - reduce dimensions progressively
+        for (const scale of scaleSteps) {
+            finalWidth = Math.round(targetWidth * scale);
+            finalHeight = Math.round(targetHeight * scale);
+            if (finalWidth < 100 || finalHeight < 100) {
+                break;
+            }
+            for (const quality of qualitySteps) {
+                best = tryBothFormats(finalWidth, finalHeight, quality);
+                if (best.buffer.length <= opts.maxBytes) {
+                    return {
+                        data: Buffer.from(best.buffer).toString("base64"),
+                        mimeType: best.mimeType,
+                        originalWidth,
+                        originalHeight,
+                        width: finalWidth,
+                        height: finalHeight,
+                        wasResized: true,
+                    };
+                }
+            }
+        }
+        // Last resort: return smallest version we produced
+        return {
+            data: Buffer.from(best.buffer).toString("base64"),
+            mimeType: best.mimeType,
+            originalWidth,
+            originalHeight,
+            width: finalWidth,
+            height: finalHeight,
+            wasResized: true,
+        };
+    }
+    catch {
+        // Failed to load image
+        return {
+            data: img.data,
+            mimeType: img.mimeType,
+            originalWidth: 0,
+            originalHeight: 0,
+            width: 0,
+            height: 0,
+            wasResized: false,
+        };
+    }
+    finally {
+        if (image) {
+            image.free();
+        }
+    }
+}
+/**
+ * Format a dimension note for resized images.
+ * This helps the model understand the coordinate mapping.
+ */
+export function formatDimensionNote(result) {
+    if (!result.wasResized) {
+        return undefined;
+    }
+    const scale = result.originalWidth / result.width;
+    return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
+}

package/dist/utils/mime.js

@@ -0,0 +1,25 @@
+import { open } from "node:fs/promises";
+import { fileTypeFromBuffer } from "file-type";
+const IMAGE_MIME_TYPES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+const FILE_TYPE_SNIFF_BYTES = 4100;
+export async function detectSupportedImageMimeTypeFromFile(filePath) {
+    const fileHandle = await open(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(FILE_TYPE_SNIFF_BYTES);
+        const { bytesRead } = await fileHandle.read(buffer, 0, FILE_TYPE_SNIFF_BYTES, 0);
+        if (bytesRead === 0) {
+            return null;
+        }
+        const fileType = await fileTypeFromBuffer(buffer.subarray(0, bytesRead));
+        if (!fileType) {
+            return null;
+        }
+        if (!IMAGE_MIME_TYPES.has(fileType.mime)) {
+            return null;
+        }
+        return fileType.mime;
+    }
+    finally {
+        await fileHandle.close();
+    }
+}

package/dist/utils/photon.js

@@ -0,0 +1,120 @@
+/**
+ * Photon image processing wrapper.
+ *
+ * This module provides a unified interface to @silvia-odwyer/photon-node that works in:
+ * 1. Node.js (development, npm run build)
+ * 2. Bun compiled binaries (standalone distribution)
+ *
+ * The challenge: photon-node's CJS entry uses fs.readFileSync(__dirname + '/photon_rs_bg.wasm')
+ * which bakes the build machine's absolute path into Bun compiled binaries.
+ *
+ * Solution:
+ * 1. Patch fs.readFileSync to redirect missing photon_rs_bg.wasm reads
+ * 2. Copy photon_rs_bg.wasm next to the executable in build:binary
+ */
+import { createRequire } from "module";
+import * as path from "path";
+import { fileURLToPath } from "url";
+const require = createRequire(import.meta.url);
+const fs = require("fs");
+const WASM_FILENAME = "photon_rs_bg.wasm";
+// Lazy-loaded photon module
+let photonModule = null;
+let loadPromise = null;
+function pathOrNull(file) {
+    if (typeof file === "string") {
+        return file;
+    }
+    if (file instanceof URL) {
+        return fileURLToPath(file);
+    }
+    return null;
+}
+function getFallbackWasmPaths() {
+    const execDir = path.dirname(process.execPath);
+    return [
+        path.join(execDir, WASM_FILENAME),
+        path.join(execDir, "photon", WASM_FILENAME),
+        path.join(process.cwd(), WASM_FILENAME),
+    ];
+}
+function patchPhotonWasmRead() {
+    const originalReadFileSync = fs.readFileSync.bind(fs);
+    const fallbackPaths = getFallbackWasmPaths();
+    const mutableFs = fs;
+    const patchedReadFileSync = ((...args) => {
+        const [file, options] = args;
+        const resolvedPath = pathOrNull(file);
+        if (resolvedPath?.endsWith(WASM_FILENAME)) {
+            try {
+                return originalReadFileSync(...args);
+            }
+            catch (error) {
+                const err = error;
+                if (err?.code && err.code !== "ENOENT") {
+                    throw error;
+                }
+                for (const fallbackPath of fallbackPaths) {
+                    if (!fs.existsSync(fallbackPath)) {
+                        continue;
+                    }
+                    if (options === undefined) {
+                        return originalReadFileSync(fallbackPath);
+                    }
+                    return originalReadFileSync(fallbackPath, options);
+                }
+                throw error;
+            }
+        }
+        return originalReadFileSync(...args);
+    });
+    try {
+        mutableFs.readFileSync = patchedReadFileSync;
+    }
+    catch {
+        Object.defineProperty(fs, "readFileSync", {
+            value: patchedReadFileSync,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return () => {
+        try {
+            mutableFs.readFileSync = originalReadFileSync;
+        }
+        catch {
+            Object.defineProperty(fs, "readFileSync", {
+                value: originalReadFileSync,
+                writable: true,
+                configurable: true,
+            });
+        }
+    };
+}
+/**
+ * Load the photon module asynchronously.
+ * Returns cached module on subsequent calls.
+ */
+export async function loadPhoton() {
+    if (photonModule) {
+        return photonModule;
+    }
+    if (loadPromise) {
+        return loadPromise;
+    }
+    loadPromise = (async () => {
+        const restoreReadFileSync = patchPhotonWasmRead();
+        try {
+            photonModule = await import("@silvia-odwyer/photon-node");
+            return photonModule;
+        }
+        catch {
+            photonModule = null;
+            return photonModule;
+        }
+        finally {
+            restoreReadFileSync();
+        }
+    })();
+    return loadPromise;
+}

package/dist/utils/shell.js

@@ -0,0 +1,164 @@
+import { existsSync } from "node:fs";
+import { delimiter } from "node:path";
+import { spawn, spawnSync } from "child_process";
+import { getBinDir, getSettingsPath } from "../config.js";
+import { SettingsManager } from "../core/settings-manager.js";
+let cachedShellConfig = null;
+/**
+ * Find bash executable on PATH (Windows)
+ */
+function findBashOnPath() {
+    try {
+        const result = spawnSync("where", ["bash.exe"], { encoding: "utf-8", timeout: 5000 });
+        if (result.status === 0 && result.stdout) {
+            const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+            if (firstMatch && existsSync(firstMatch)) {
+                return firstMatch;
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Get shell configuration based on platform.
+ * Resolution order:
+ * 1. User-specified shellPath in settings.json
+ * 2. On Windows: Git Bash in known locations, then bash on PATH
+ * 3. On Unix: /bin/bash
+ * 4. Fallback: sh
+ */
+export function getShellConfig() {
+    if (cachedShellConfig) {
+        return cachedShellConfig;
+    }
+    const settings = SettingsManager.create();
+    const customShellPath = settings.getShellPath();
+    // 1. Check user-specified shell path
+    if (customShellPath) {
+        if (existsSync(customShellPath)) {
+            cachedShellConfig = { shell: customShellPath, args: ["-c"] };
+            return cachedShellConfig;
+        }
+        throw new Error(`Custom shell path not found: ${customShellPath}\nPlease update shellPath in ${getSettingsPath()}`);
+    }
+    if (process.platform === "win32") {
+        // 2. Try Git Bash in known locations
+        const paths = [];
+        const programFiles = process.env.ProgramFiles;
+        if (programFiles) {
+            paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
+        }
+        const programFilesX86 = process.env["ProgramFiles(x86)"];
+        if (programFilesX86) {
+            paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+        }
+        for (const path of paths) {
+            if (existsSync(path)) {
+                cachedShellConfig = { shell: path, args: ["-c"] };
+                return cachedShellConfig;
+            }
+        }
+        // 3. Fallback: search bash.exe on PATH (Cygwin, MSYS2, WSL, etc.)
+        const bashOnPath = findBashOnPath();
+        if (bashOnPath) {
+            cachedShellConfig = { shell: bashOnPath, args: ["-c"] };
+            return cachedShellConfig;
+        }
+        throw new Error(`No bash shell found. Options:\n` +
+            `  1. Install Git for Windows: https://git-scm.com/download/win\n` +
+            `  2. Add your bash to PATH (Cygwin, MSYS2, etc.)\n` +
+            `  3. Set shellPath in ${getSettingsPath()}\n\n` +
+            `Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`);
+    }
+    // Unix: prefer bash over sh
+    if (existsSync("/bin/bash")) {
+        cachedShellConfig = { shell: "/bin/bash", args: ["-c"] };
+        return cachedShellConfig;
+    }
+    cachedShellConfig = { shell: "sh", args: ["-c"] };
+    return cachedShellConfig;
+}
+export function getShellEnv() {
+    const binDir = getBinDir();
+    const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+    const currentPath = process.env[pathKey] ?? "";
+    const pathEntries = currentPath.split(delimiter).filter(Boolean);
+    const hasBinDir = pathEntries.includes(binDir);
+    const updatedPath = hasBinDir ? currentPath : [binDir, currentPath].filter(Boolean).join(delimiter);
+    return {
+        ...process.env,
+        [pathKey]: updatedPath,
+    };
+}
+/**
+ * Sanitize binary output for display/storage.
+ * Removes characters that crash string-width or cause display issues:
+ * - Control characters (except tab, newline, carriage return)
+ * - Lone surrogates
+ * - Unicode Format characters (crash string-width due to a bug)
+ * - Characters with undefined code points
+ */
+export function sanitizeBinaryOutput(str) {
+    // Use Array.from to properly iterate over code points (not code units)
+    // This handles surrogate pairs correctly and catches edge cases where
+    // codePointAt() might return undefined
+    return Array.from(str)
+        .filter((char) => {
+        // Filter out characters that cause string-width to crash
+        // This includes:
+        // - Unicode format characters
+        // - Lone surrogates (already filtered by Array.from)
+        // - Control chars except \t \n \r
+        // - Characters with undefined code points
+        const code = char.codePointAt(0);
+        // Skip if code point is undefined (edge case with invalid strings)
+        if (code === undefined)
+            return false;
+        // Allow tab, newline, carriage return
+        if (code === 0x09 || code === 0x0a || code === 0x0d)
+            return true;
+        // Filter out control characters (0x00-0x1F, except 0x09, 0x0a, 0x0x0d)
+        if (code <= 0x1f)
+            return false;
+        // Filter out Unicode format characters
+        if (code >= 0xfff9 && code <= 0xfffb)
+            return false;
+        return true;
+    })
+        .join("");
+}
+/**
+ * Kill a process and all its children (cross-platform)
+ */
+export function killProcessTree(pid) {
+    if (process.platform === "win32") {
+        // Use taskkill on Windows to kill process tree
+        try {
+            spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+                stdio: "ignore",
+                detached: true,
+            });
+        }
+        catch {
+            // Ignore errors if taskkill fails
+        }
+    }
+    else {
+        // Use SIGKILL on Unix/Linux/Mac
+        try {
+            process.kill(-pid, "SIGKILL");
+        }
+        catch {
+            // Fallback to killing just the child if process group kill fails
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch {
+                // Process already dead
+            }
+        }
+    }
+}

package/dist/utils/sleep.js

@@ -0,0 +1,16 @@
+/**
+ * Sleep helper that respects abort signal.
+ */
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error("Aborted"));
+            return;
+        }
+        const timeout = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            reject(new Error("Aborted"));
+        });
+    });
+}