indusagi-coding-agent 0.1.0

package/dist/core/tools/bash.js

@@ -0,0 +1,226 @@
+import { randomBytes } from "node:crypto";
+import { createWriteStream, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { spawn } from "child_process";
+import { getShellConfig, getShellEnv, killProcessTree } from "../../utils/shell.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateTail } from "./truncate.js";
+/**
+ * Generate a unique temp file path for bash output
+ */
+function getTempFilePath() {
+    const id = randomBytes(8).toString("hex");
+    return join(tmpdir(), `indusagi-bash-${id}.log`);
+}
+const bashSchema = Type.Object({
+    command: Type.String({ description: "Bash command to execute" }),
+    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+/**
+ * Default bash operations using local shell
+ */
+const defaultBashOperations = {
+    exec: (command, cwd, { onData, signal, timeout }) => {
+        return new Promise((resolve, reject) => {
+            const { shell, args } = getShellConfig();
+            if (!existsSync(cwd)) {
+                reject(new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`));
+                return;
+            }
+            const child = spawn(shell, [...args, command], {
+                cwd,
+                detached: true,
+                env: getShellEnv(),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let timedOut = false;
+            // Set timeout if provided
+            let timeoutHandle;
+            if (timeout !== undefined && timeout > 0) {
+                timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    if (child.pid) {
+                        killProcessTree(child.pid);
+                    }
+                }, timeout * 1000);
+            }
+            // Stream stdout and stderr
+            if (child.stdout) {
+                child.stdout.on("data", onData);
+            }
+            if (child.stderr) {
+                child.stderr.on("data", onData);
+            }
+            // Handle shell spawn errors
+            child.on("error", (err) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+                reject(err);
+            });
+            // Handle abort signal - kill entire process tree
+            const onAbort = () => {
+                if (child.pid) {
+                    killProcessTree(child.pid);
+                }
+            };
+            if (signal) {
+                if (signal.aborted) {
+                    onAbort();
+                }
+                else {
+                    signal.addEventListener("abort", onAbort, { once: true });
+                }
+            }
+            // Handle process exit
+            child.on("close", (code) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+                if (signal?.aborted) {
+                    reject(new Error("aborted"));
+                    return;
+                }
+                if (timedOut) {
+                    reject(new Error(`timeout:${timeout}`));
+                    return;
+                }
+                resolve({ exitCode: code });
+            });
+        });
+    },
+};
+export function createBashTool(cwd, options) {
+    const ops = options?.operations ?? defaultBashOperations;
+    const commandPrefix = options?.commandPrefix;
+    return {
+        name: "bash",
+        label: "bash",
+        description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+        parameters: bashSchema,
+        execute: async (_toolCallId, { command, timeout }, signal, onUpdate) => {
+            // Apply command prefix if configured (e.g., "shopt -s expand_aliases" for alias support)
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            return new Promise((resolve, reject) => {
+                // We'll stream to a temp file if output gets large
+                let tempFilePath;
+                let tempFileStream;
+                let totalBytes = 0;
+                // Keep a rolling buffer of the last chunk for tail truncation
+                const chunks = [];
+                let chunksBytes = 0;
+                // Keep more than we need so we have enough for truncation
+                const maxChunksBytes = DEFAULT_MAX_BYTES * 2;
+                const handleData = (data) => {
+                    totalBytes += data.length;
+                    // Start writing to temp file once we exceed the threshold
+                    if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
+                        tempFilePath = getTempFilePath();
+                        tempFileStream = createWriteStream(tempFilePath);
+                        // Write all buffered chunks to the file
+                        for (const chunk of chunks) {
+                            tempFileStream.write(chunk);
+                        }
+                    }
+                    // Write to temp file if we have one
+                    if (tempFileStream) {
+                        tempFileStream.write(data);
+                    }
+                    // Keep rolling buffer of recent data
+                    chunks.push(data);
+                    chunksBytes += data.length;
+                    // Trim old chunks if buffer is too large
+                    while (chunksBytes > maxChunksBytes && chunks.length > 1) {
+                        const removed = chunks.shift();
+                        chunksBytes -= removed.length;
+                    }
+                    // Stream partial output to callback (truncated rolling buffer)
+                    if (onUpdate) {
+                        const fullBuffer = Buffer.concat(chunks);
+                        const fullText = fullBuffer.toString("utf-8");
+                        const truncation = truncateTail(fullText);
+                        onUpdate({
+                            content: [{ type: "text", text: truncation.content || "" }],
+                            details: {
+                                truncation: truncation.truncated ? truncation : undefined,
+                                fullOutputPath: tempFilePath,
+                            },
+                        });
+                    }
+                };
+                ops.exec(resolvedCommand, cwd, { onData: handleData, signal, timeout })
+                    .then(({ exitCode }) => {
+                    // Close temp file stream
+                    if (tempFileStream) {
+                        tempFileStream.end();
+                    }
+                    // Combine all buffered chunks
+                    const fullBuffer = Buffer.concat(chunks);
+                    const fullOutput = fullBuffer.toString("utf-8");
+                    // Apply tail truncation
+                    const truncation = truncateTail(fullOutput);
+                    let outputText = truncation.content || "(no output)";
+                    // Build details with truncation info
+                    let details;
+                    if (truncation.truncated) {
+                        details = {
+                            truncation,
+                            fullOutputPath: tempFilePath,
+                        };
+                        // Build actionable notice
+                        const startLine = truncation.totalLines - truncation.outputLines + 1;
+                        const endLine = truncation.totalLines;
+                        if (truncation.lastLinePartial) {
+                            // Edge case: last line alone > 30KB
+                            const lastLineSize = formatSize(Buffer.byteLength(fullOutput.split("\n").pop() || "", "utf-8"));
+                            outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${tempFilePath}]`;
+                        }
+                        else if (truncation.truncatedBy === "lines") {
+                            outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${tempFilePath}]`;
+                        }
+                        else {
+                            outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${tempFilePath}]`;
+                        }
+                    }
+                    if (exitCode !== 0 && exitCode !== null) {
+                        outputText += `\n\nCommand exited with code ${exitCode}`;
+                        reject(new Error(outputText));
+                    }
+                    else {
+                        resolve({ content: [{ type: "text", text: outputText }], details });
+                    }
+                })
+                    .catch((err) => {
+                    // Close temp file stream
+                    if (tempFileStream) {
+                        tempFileStream.end();
+                    }
+                    // Combine all buffered chunks for error output
+                    const fullBuffer = Buffer.concat(chunks);
+                    let output = fullBuffer.toString("utf-8");
+                    if (err.message === "aborted") {
+                        if (output)
+                            output += "\n\n";
+                        output += "Command aborted";
+                        reject(new Error(output));
+                    }
+                    else if (err.message.startsWith("timeout:")) {
+                        const timeoutSecs = err.message.split(":")[1];
+                        if (output)
+                            output += "\n\n";
+                        output += `Command timed out after ${timeoutSecs} seconds`;
+                        reject(new Error(output));
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            });
+        },
+    };
+}
+/** Default bash tool using process.cwd() - for backwards compatibility */
+export const bashTool = createBashTool(process.cwd());

package/dist/core/tools/edit-diff.js

@@ -0,0 +1,242 @@
+/**
+ * Shared diff computation utilities for the edit tool.
+ * Used by both edit.ts (for execution) and tool-execution.ts (for preview rendering).
+ */
+import * as Diff from "diff";
+import { constants } from "fs";
+import { access, readFile } from "fs/promises";
+import { resolveToCwd } from "./path-utils.js";
+export function detectLineEnding(content) {
+    const crlfIdx = content.indexOf("\r\n");
+    const lfIdx = content.indexOf("\n");
+    if (lfIdx === -1)
+        return "\n";
+    if (crlfIdx === -1)
+        return "\n";
+    return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+export function normalizeToLF(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function restoreLineEndings(text, ending) {
+    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+/**
+ * Normalize text for fuzzy matching. Applies progressive transformations:
+ * - Strip trailing whitespace from each line
+ * - Normalize smart quotes to ASCII equivalents
+ * - Normalize Unicode dashes/hyphens to ASCII hyphen
+ * - Normalize special Unicode spaces to regular space
+ */
+export function normalizeForFuzzyMatch(text) {
+    return (text
+        // Strip trailing whitespace per line
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n")
+        // Smart single quotes → '
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        // Smart double quotes → "
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+        // Various dashes/hyphens → -
+        // U+2010 hyphen, U+2011 non-breaking hyphen, U+2012 figure dash,
+        // U+2013 en-dash, U+2014 em-dash, U+2015 horizontal bar, U+2212 minus
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+        // Special spaces → regular space
+        // U+00A0 NBSP, U+2002-U+200A various spaces, U+202F narrow NBSP,
+        // U+205F medium math space, U+3000 ideographic space
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "));
+}
+/**
+ * Find oldText in content, trying exact match first, then fuzzy match.
+ * When fuzzy matching is used, the returned contentForReplacement is the
+ * fuzzy-normalized version of the content (trailing whitespace stripped,
+ * Unicode quotes/dashes normalized to ASCII).
+ */
+export function fuzzyFindText(content, oldText) {
+    // Try exact match first
+    const exactIndex = content.indexOf(oldText);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            index: exactIndex,
+            matchLength: oldText.length,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    // Try fuzzy match - work entirely in normalized space
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+    const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+    if (fuzzyIndex === -1) {
+        return {
+            found: false,
+            index: -1,
+            matchLength: 0,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    // When fuzzy matching, we work in the normalized space for replacement.
+    // This means the output will have normalized whitespace/quotes/dashes,
+    // which is acceptable since we're fixing minor formatting differences anyway.
+    return {
+        found: true,
+        index: fuzzyIndex,
+        matchLength: fuzzyOldText.length,
+        usedFuzzyMatch: true,
+        contentForReplacement: fuzzyContent,
+    };
+}
+/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
+export function stripBom(content) {
+    return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+/**
+ * Generate a unified diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export function generateDiffString(oldContent, newContent, contextLines = 4) {
+    const parts = Diff.diffLines(oldContent, newContent);
+    const output = [];
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    const maxLineNum = Math.max(oldLines.length, newLines.length);
+    const lineNumWidth = String(maxLineNum).length;
+    let oldLineNum = 1;
+    let newLineNum = 1;
+    let lastWasChange = false;
+    let firstChangedLine;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const raw = part.value.split("\n");
+        if (raw[raw.length - 1] === "") {
+            raw.pop();
+        }
+        if (part.added || part.removed) {
+            // Capture the first changed line (in the new file)
+            if (firstChangedLine === undefined) {
+                firstChangedLine = newLineNum;
+            }
+            // Show the change
+            for (const line of raw) {
+                if (part.added) {
+                    const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+                    output.push(`+${lineNum} ${line}`);
+                    newLineNum++;
+                }
+                else {
+                    // removed
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(`-${lineNum} ${line}`);
+                    oldLineNum++;
+                }
+            }
+            lastWasChange = true;
+        }
+        else {
+            // Context lines - only show a few before/after changes
+            const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+            if (lastWasChange || nextPartIsChange) {
+                // Show context
+                let linesToShow = raw;
+                let skipStart = 0;
+                let skipEnd = 0;
+                if (!lastWasChange) {
+                    // Show only last N lines as leading context
+                    skipStart = Math.max(0, raw.length - contextLines);
+                    linesToShow = raw.slice(skipStart);
+                }
+                if (!nextPartIsChange && linesToShow.length > contextLines) {
+                    // Show only first N lines as trailing context
+                    skipEnd = linesToShow.length - contextLines;
+                    linesToShow = linesToShow.slice(0, contextLines);
+                }
+                // Add ellipsis if we skipped lines at start
+                if (skipStart > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    // Update line numbers for the skipped leading context
+                    oldLineNum += skipStart;
+                    newLineNum += skipStart;
+                }
+                for (const line of linesToShow) {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(` ${lineNum} ${line}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+                // Add ellipsis if we skipped lines at end
+                if (skipEnd > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    // Update line numbers for the skipped trailing context
+                    oldLineNum += skipEnd;
+                    newLineNum += skipEnd;
+                }
+            }
+            else {
+                // Skip these context lines entirely
+                oldLineNum += raw.length;
+                newLineNum += raw.length;
+            }
+            lastWasChange = false;
+        }
+    }
+    return { diff: output.join("\n"), firstChangedLine };
+}
+/**
+ * Compute the diff for an edit operation without applying it.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export async function computeEditDiff(path, oldText, newText, cwd) {
+    const absolutePath = resolveToCwd(path, cwd);
+    try {
+        // Check if file exists and is readable
+        try {
+            await access(absolutePath, constants.R_OK);
+        }
+        catch {
+            return { error: `File not found: ${path}` };
+        }
+        // Read the file
+        const rawContent = await readFile(absolutePath, "utf-8");
+        // Strip BOM before matching (LLM won't include invisible BOM in oldText)
+        const { text: content } = stripBom(rawContent);
+        const normalizedContent = normalizeToLF(content);
+        const normalizedOldText = normalizeToLF(oldText);
+        const normalizedNewText = normalizeToLF(newText);
+        // Find the old text using fuzzy matching (tries exact match first, then fuzzy)
+        const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+        if (!matchResult.found) {
+            return {
+                error: `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`,
+            };
+        }
+        // Count occurrences using fuzzy-normalized content for consistency
+        const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
+        const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+        const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+        if (occurrences > 1) {
+            return {
+                error: `Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,
+            };
+        }
+        // Compute the new content using the matched position
+        // When fuzzy matching was used, contentForReplacement is the normalized version
+        const baseContent = matchResult.contentForReplacement;
+        const newContent = baseContent.substring(0, matchResult.index) +
+            normalizedNewText +
+            baseContent.substring(matchResult.index + matchResult.matchLength);
+        // Check if it would actually change anything
+        if (baseContent === newContent) {
+            return {
+                error: `No changes would be made to ${path}. The replacement produces identical content.`,
+            };
+        }
+        // Generate the diff
+        return generateDiffString(baseContent, newContent);
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/core/tools/edit.js

@@ -0,0 +1,145 @@
+import { Type } from "@sinclair/typebox";
+import { constants } from "fs";
+import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
+import { detectLineEnding, fuzzyFindText, generateDiffString, normalizeForFuzzyMatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { resolveToCwd } from "./path-utils.js";
+const editSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+    oldText: Type.String({ description: "Exact text to find and replace (must match exactly)" }),
+    newText: Type.String({ description: "New text to replace the old text with" }),
+});
+const defaultEditOperations = {
+    readFile: (path) => fsReadFile(path),
+    writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+    access: (path) => fsAccess(path, constants.R_OK | constants.W_OK),
+};
+export function createEditTool(cwd, options) {
+    const ops = options?.operations ?? defaultEditOperations;
+    return {
+        name: "edit",
+        label: "edit",
+        description: "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
+        parameters: editSchema,
+        execute: async (_toolCallId, { path, oldText, newText }, signal) => {
+            const absolutePath = resolveToCwd(path, cwd);
+            return new Promise((resolve, reject) => {
+                // Check if already aborted
+                if (signal?.aborted) {
+                    reject(new Error("Operation aborted"));
+                    return;
+                }
+                let aborted = false;
+                // Set up abort handler
+                const onAbort = () => {
+                    aborted = true;
+                    reject(new Error("Operation aborted"));
+                };
+                if (signal) {
+                    signal.addEventListener("abort", onAbort, { once: true });
+                }
+                // Perform the edit operation
+                (async () => {
+                    try {
+                        // Check if file exists
+                        try {
+                            await ops.access(absolutePath);
+                        }
+                        catch {
+                            if (signal) {
+                                signal.removeEventListener("abort", onAbort);
+                            }
+                            reject(new Error(`File not found: ${path}`));
+                            return;
+                        }
+                        // Check if aborted before reading
+                        if (aborted) {
+                            return;
+                        }
+                        // Read the file
+                        const buffer = await ops.readFile(absolutePath);
+                        const rawContent = buffer.toString("utf-8");
+                        // Check if aborted after reading
+                        if (aborted) {
+                            return;
+                        }
+                        // Strip BOM before matching (LLM won't include invisible BOM in oldText)
+                        const { bom, text: content } = stripBom(rawContent);
+                        const originalEnding = detectLineEnding(content);
+                        const normalizedContent = normalizeToLF(content);
+                        const normalizedOldText = normalizeToLF(oldText);
+                        const normalizedNewText = normalizeToLF(newText);
+                        // Find the old text using fuzzy matching (tries exact match first, then fuzzy)
+                        const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+                        if (!matchResult.found) {
+                            if (signal) {
+                                signal.removeEventListener("abort", onAbort);
+                            }
+                            reject(new Error(`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`));
+                            return;
+                        }
+                        // Count occurrences using fuzzy-normalized content for consistency
+                        const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
+                        const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+                        const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+                        if (occurrences > 1) {
+                            if (signal) {
+                                signal.removeEventListener("abort", onAbort);
+                            }
+                            reject(new Error(`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`));
+                            return;
+                        }
+                        // Check if aborted before writing
+                        if (aborted) {
+                            return;
+                        }
+                        // Perform replacement using the matched text position
+                        // When fuzzy matching was used, contentForReplacement is the normalized version
+                        const baseContent = matchResult.contentForReplacement;
+                        const newContent = baseContent.substring(0, matchResult.index) +
+                            normalizedNewText +
+                            baseContent.substring(matchResult.index + matchResult.matchLength);
+                        // Verify the replacement actually changed something
+                        if (baseContent === newContent) {
+                            if (signal) {
+                                signal.removeEventListener("abort", onAbort);
+                            }
+                            reject(new Error(`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`));
+                            return;
+                        }
+                        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                        await ops.writeFile(absolutePath, finalContent);
+                        // Check if aborted after writing
+                        if (aborted) {
+                            return;
+                        }
+                        // Clean up abort handler
+                        if (signal) {
+                            signal.removeEventListener("abort", onAbort);
+                        }
+                        const diffResult = generateDiffString(baseContent, newContent);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Successfully replaced text in ${path}.`,
+                                },
+                            ],
+                            details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine },
+                        });
+                    }
+                    catch (error) {
+                        // Clean up abort handler
+                        if (signal) {
+                            signal.removeEventListener("abort", onAbort);
+                        }
+                        if (!aborted) {
+                            reject(error);
+                        }
+                    }
+                })();
+            });
+        },
+    };
+}
+/** Default edit tool using process.cwd() - for backwards compatibility */
+export const editTool = createEditTool(process.cwd());