@travisennis/acai 0.0.4 → 0.0.6

package/dist/prompts.js

@@ -1,8 +1,10 @@
+import { execSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { platform } from "node:os";
 import path from "node:path";
 import { config } from "./config.js";
 import { dedent } from "./dedent.js";
+import { getShell } from "./terminal/index.js";
 import { AgentTool } from "./tools/agent.js";
 import { BashTool } from "./tools/bash.js";
 import { CodeInterpreterTool } from "./tools/code-interpreter.js";
@@ -33,7 +35,7 @@ async function instructions() {
     }
     return `## Core Principles
 
-- **CLI-Optimized**: Be concise and direct - responses appear in a terminal.
+- **CLI-Optimized**: Be concise and direct - responses appear in a terminal. Be extremely concise. Sacrifice grammar for the sake of concision.
 - **Progressive Problem Solving**: Work through problems methodically until resolution.
 - **User Authority**: NEVER commit changes or add dependencies without explicit user approval.
 - **Security-First**: Prioritize secure coding practices in all suggestions.
@@ -66,12 +68,13 @@ function toolUsage() {
     return `## Tool Usage Guidelines
 
 ### Information Gathering
-- Use \`${DirectoryTreeTool.name}\` for project structure
+- Prefer targeted queries: use \`${GrepTool.name}\` for code pattern searches and \`${ReadMultipleFilesTool.name}\` to fetch files. Avoid full directory dumps for large repositories.
 - Use \`${ReadFileTool.name}\` or \`${ReadMultipleFilesTool.name}\` for file contents if filenames are provided in the prompt
 - Use \`${GrepTool.name}\` for code pattern searches
 - Use \`${WebFetchTool.name}\` for text-based URLs provided in the prompt
 - Use \`${WebSearchTool.name}\` for external research (e.g., libraries, errors)
-- Use \`${AgentTool.name}\` for iterative keyword/file searches. Use this if you need to explore the project fo find what you are looking for.
+- Use \`${AgentTool.name}\` for iterative keyword/file searches. Use this if you need to explore the project to find what you are looking for.
+- Use \`${DirectoryTreeTool.name}\` if you need a high-level overview of the project. 
 - If file contents or URLs are provided in the prompt, use them directly without re-fetching
 - Always verify file contents before suggesting changes unless provided in the prompt
 
@@ -85,18 +88,38 @@ function toolUsage() {
 - Outline multi-step tasks before execution
 
 ### Bash Commands (\`${BashTool.name}\`)
-- Shell is disabled. Do NOT use: |, >, >>, <, <<, ;, &&, ||, &, \`...\`, $().
-- Run a single allowed command with quoted args; no command substitution or chaining.
-- Compose multi-step flows via multiple tool calls or program flags (rg, jq, grep options, etc.).
-- For large gh/git messages, prefer --message-file instead of inlining big strings.
+- Execute commands with a sandboxed executor that supports pipes (|), conditional chaining (&&, ||, ;), and redirection (> >> < 2> 2>>).
+- Run single commands or compose multi-step flows using shell operators.
+- For extremely large gh/git messages:
+  1. Create temp file with ${SaveFileTool.name} in the project's .tmp directory
+  2. Use git commit --file path/to/temp/file or gh pr create --title "Title of PR" --body-file path/to/temp/file
+- Note: The .tmp directory in the current working directory is deleted each time the agent shuts down.
 - Commands execute only within the project directory; always use absolute paths.
 - Avoid interactive commands; prefer non-interactive flags (e.g., npm init -y).
 
+#### Additional Installed Tools
+
+${getInstalledTools()}
+
 ### Code Interpreter (\`${CodeInterpreterTool.name}\`)
 - Executes JavaScript code in a separate Node.js process using Node's Permission Model
 - By default, the child process has no permissions except read/write within the current working directory
 - Returns stdout, stderr, and exitCode
-- Use console.log/console.error to produce outpu`;
+- Use console.log/console.error to produce output
+
+### Git Workflow
+- Always stage changes before attempting to commit them
+- Never amend git commits without approval from the user
+- Never use \`git add -A\` when preparing for multiple, distinct commits; instead, selectively add files or hunks relevant to each commit
+- Always use \`git checkout -b <branch-name>\` with a branch name that accurately reflects the *type* of changes being made
+- Never stage changes for files that are specified in \`.gitignore\`
+- Always stage changes after running a formatter that modifies files, before attempting to commit
+
+### Efficiency Guidelines
+- Always use the most efficient workflow to complete tasks
+- Never re-read file content that has already been provided in the current turn or is directly accessible via a tool; instead, reuse the provided content or reference the file path directly
+- Always use direct file paths or established methods to pass content to tools that accept file input, rather than re-creating content in command strings
+- Always run a build after making code changes to verify correctness`;
 }
 function escalationProcedures() {
     return `## Escalation
@@ -122,17 +145,19 @@ async function environmentInfo() {
     const gitDirectory = await inGitDirectory();
     let gitSection = `- **Is directory a git repo**: ${gitDirectory ? "Yes" : "No"}`;
     if (gitDirectory) {
-        gitSection += `\n- ** Current git branch**: ${await getCurrentBranch()}`;
+        gitSection += `\n- **Current git branch**: ${await getCurrentBranch()}`;
     }
     return `## Environment
 
 - **Current working directory**: ${process.cwd()}. [Use this value directly instead of calling the \`${BashTool.name}(pwd)\` tool unless you have a specific reason to verify it].
 ${gitSection}
 - **Platform**: ${platform()}
-- **Today's date**: ${(new Date()).toISOString()}`;
+- **Shell**: ${getShell()}
+- **Today's date**: ${(new Date()).toISOString()}
+- Note: The .tmp directory in the current working directory is deleted each time the agent shuts down.`;
 }
 export async function systemPrompt(options) {
-    const { supportsToolCalling = true } = options ?? {};
+    const { supportsToolCalling = true, includeRules = true } = options ?? {};
     const prompt = dedent `
 ${intro()}
 
@@ -142,7 +167,7 @@ ${supportsToolCalling ? toolUsage() : ""}
 
 ${escalationProcedures()}
 
-${await getRules()}
+${includeRules ? await getRules() : ""}
 
 ${await environmentInfo()}
 `;
@@ -160,3 +185,31 @@ ${await environmentInfo()}
 `;
     return prompt;
 }
+function getInstalledTools() {
+    // Check for required bash tools
+    const tools = [
+        { name: "git", command: "git --version" },
+        { name: "gh", command: "gh --version" },
+        { name: "rg", command: "rg --version" },
+        { name: "fd", command: "fd --version" },
+        { name: "ast-grep", command: "ast-grep --version" },
+        { name: "jq", command: "jq --version" },
+        { name: "yq", command: "yq --version" },
+    ];
+    const toolStatus = tools
+        .map((tool) => {
+        let status = false;
+        try {
+            execSync(tool.command, { stdio: "ignore", timeout: 5000 });
+            status = true;
+        }
+        catch (_error) {
+            // Ignore error, tool is not installed
+        }
+        return [tool.name, status];
+    })
+        .filter((tool) => tool[1])
+        .map((tool) => tool[0])
+        .join("\n");
+    return toolStatus;
+}

package/dist/repl/display-tool-messages.d.ts

@@ -0,0 +1,4 @@
+import type { Terminal } from "../terminal/index.ts";
+import type { Message } from "../tools/types.ts";
+export declare function displayToolMessages(message: Message, terminal: Terminal): void;
+//# sourceMappingURL=display-tool-messages.d.ts.map

package/dist/repl/display-tool-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-tool-messages.d.ts","sourceRoot":"","sources":["../../source/repl/display-tool-messages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,QAmBvE"}

package/dist/repl/display-tool-messages.js

@@ -0,0 +1,58 @@
+import { capitalize } from "../formatting.js";
+import { logger } from "../logger.js";
+import style from "../terminal/style.js";
+export function displayToolMessages(message, terminal) {
+    switch (message.event) {
+        case "tool-completion":
+            handleToolCompletionMessage(message, terminal);
+            break;
+        case "tool-error":
+            handleToolErrorMessage(message, terminal);
+            break;
+        case "tool-init":
+            handleToolInitMessage(message, terminal);
+            break;
+        default:
+            logger.debug(`Unhandled tool message event: ${message.event}`);
+            break;
+    }
+    terminal.lineBreak();
+}
+function handleToolInitMessage(message, terminal) {
+    const indicator = style.blue.bold("●");
+    const data = String(message.data);
+    const newlineIndex = data.indexOf("\n");
+    terminal.write(`${indicator} ${style.bold(capitalize(message.name))} `);
+    if (newlineIndex === -1) {
+        terminal.writeln(style.bold(data));
+    }
+    else {
+        const firstLine = data.slice(0, newlineIndex);
+        const remainingLines = data.slice(newlineIndex + 1);
+        terminal.writeln(style.bold(firstLine));
+        if (remainingLines.trim()) {
+            terminal.display(remainingLines);
+        }
+    }
+}
+function handleToolCompletionMessage(message, terminal) {
+    const indicator = style.green.bold("●");
+    const data = String(message.data);
+    const newlineIndex = data.indexOf("\n");
+    terminal.write(`${indicator} ${style.bold(capitalize(message.name))} `);
+    if (newlineIndex === -1) {
+        terminal.writeln(style.bold(data));
+    }
+    else {
+        const firstLine = data.slice(0, newlineIndex);
+        const remainingLines = data.slice(newlineIndex + 1);
+        terminal.writeln(style.bold(firstLine));
+        if (remainingLines.trim()) {
+            terminal.display(remainingLines);
+        }
+    }
+}
+function handleToolErrorMessage(message, terminal) {
+    const indicator = style.red.bold("●");
+    terminal.writeln(`${indicator} ${style.bold(capitalize(message.name))} ${message.data}`);
+}

package/dist/repl/display-tool-use.d.ts

@@ -0,0 +1,14 @@
+import type { Terminal } from "../terminal/index.ts";
+interface MinimalStep {
+    toolResults: Array<{
+        toolName: string;
+    }>;
+    toolCalls: Array<{
+        toolName: string;
+    }>;
+}
+export declare function displayToolUse(result: {
+    steps: MinimalStep[];
+}, terminal: Terminal): void;
+export {};
+//# sourceMappingURL=display-tool-use.d.ts.map

package/dist/repl/display-tool-use.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-tool-use.d.ts","sourceRoot":"","sources":["../../source/repl/display-tool-use.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIrD,UAAU,WAAW;IACnB,WAAW,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzC,SAAS,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxC;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE;IAAE,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE,EAChC,QAAQ,EAAE,QAAQ,QA0EnB"}

package/dist/repl/display-tool-use.js

@@ -0,0 +1,63 @@
+import style from "../terminal/style.js";
+export function displayToolUse(result, terminal) {
+    const toolsCalled = [];
+    const toolColors = new Map();
+    const styleColors = [
+        "red",
+        "green",
+        "yellow",
+        "blue",
+        "magenta",
+        "cyan",
+        "white",
+        "gray",
+        "redBright",
+        "greenBright",
+        "yellowBright",
+        "blueBright",
+        "magentaBright",
+        "cyanBright",
+        "whiteBright",
+        "blackBright",
+    ];
+    terminal.writeln(style.dim(`Steps: ${result.steps.length}`));
+    for (const step of result.steps) {
+        let currentToolCalls = [];
+        if (step.toolResults.length > 0) {
+            currentToolCalls = step.toolResults;
+        }
+        else if (step.toolCalls.length > 0) {
+            currentToolCalls = step.toolCalls;
+        }
+        for (const toolCallOrResult of currentToolCalls) {
+            const toolName = toolCallOrResult.toolName;
+            if (!toolColors.has(toolName)) {
+                const availableColors = styleColors.filter((color) => !Array.from(toolColors.values()).some((c) => c === style[color]));
+                const color = availableColors.length > 0
+                    ? (availableColors[Math.floor(Math.random() * availableColors.length)] ?? "white")
+                    : "white";
+                toolColors.set(toolName, style[color]);
+            }
+            toolsCalled.push(toolName);
+        }
+    }
+    if (toolsCalled.length > 0) {
+        terminal.lineBreak();
+        terminal.writeln(style.dim("Tools:"));
+        for (const toolCalled of toolsCalled) {
+            const colorFn = toolColors.get(toolCalled) ?? style.white;
+            terminal.write(`${colorFn("██")} `);
+        }
+        terminal.lineBreak();
+        const uniqueTools = new Set(toolsCalled);
+        for (const [index, toolCalled] of Array.from(uniqueTools).entries()) {
+            const colorFn = toolColors.get(toolCalled) ?? style.white;
+            terminal.write(colorFn(toolCalled));
+            if (index < new Set(toolsCalled).size - 1) {
+                terminal.write(" - ");
+            }
+        }
+        terminal.lineBreak();
+        terminal.lineBreak();
+    }
+}

package/dist/repl/get-prompt-header.d.ts

@@ -0,0 +1,8 @@
+import type { Terminal } from "../terminal/index.ts";
+export declare function getPromptHeader(args: {
+    terminal: Terminal;
+    modelId: string;
+    contextWindow: number;
+    currentContextWindow: number;
+}): Promise<void>;
+//# sourceMappingURL=get-prompt-header.d.ts.map

package/dist/repl/get-prompt-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-prompt-header.d.ts","sourceRoot":"","sources":["../../source/repl/get-prompt-header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIrD,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;CAC9B,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhB"}

package/dist/repl/get-prompt-header.js

@@ -0,0 +1,9 @@
+import style from "../terminal/style.js";
+import { getProjectStatusLine } from "./project-status-line.js";
+export async function getPromptHeader(args) {
+    const { terminal, modelId, contextWindow, currentContextWindow } = args;
+    terminal.hr();
+    terminal.writeln(await getProjectStatusLine());
+    terminal.writeln(style.dim(modelId));
+    terminal.displayProgressBar(currentContextWindow, contextWindow);
+}

package/dist/repl/project-status-line.d.ts

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

package/dist/repl/project-status-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-status-line.d.ts","sourceRoot":"","sources":["../../source/repl/project-status-line.ts"],"names":[],"mappings":"AASA,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CA2B5D"}

package/dist/repl/project-status-line.js

@@ -0,0 +1,31 @@
+import style from "../terminal/style.js";
+import { getCurrentBranch, getDiffStat, getGitStatus, hasUncommittedChanges, inGitDirectory, } from "../tools/git-utils.js";
+export async function getProjectStatusLine() {
+    const currentDir = process.cwd().split("/").pop() || process.cwd();
+    const branch = await getCurrentBranch();
+    let gitStatus = "";
+    if (branch) {
+        const hasChanges = await hasUncommittedChanges();
+        const asterisk = hasChanges ? "*" : "";
+        gitStatus = ` ${style.gray(branch + asterisk)}`;
+    }
+    if (await inGitDirectory()) {
+        const stats = await getDiffStat();
+        const fileChanges = await getGitStatus();
+        let fileStatus = "";
+        if (fileChanges.added)
+            fileStatus += ` +${fileChanges.added}`;
+        if (fileChanges.modified)
+            fileStatus += ` ~${fileChanges.modified}`;
+        if (fileChanges.deleted)
+            fileStatus += ` -${fileChanges.deleted}`;
+        if (fileChanges.untracked)
+            fileStatus += ` ?${fileChanges.untracked}`;
+        gitStatus +=
+            " " +
+                `${style.dim("[")}${style.yellow(fileStatus.trim())} ` +
+                `${style.green(`+${stats.insertions}`)} ` +
+                `${style.red(`-${stats.deletions}`)}${style.dim("]")}`;
+    }
+    return `${style.blue(currentDir)}${gitStatus}`;
+}

package/dist/repl/prompt.d.ts

@@ -0,0 +1,21 @@
+import type { CommandManager } from "../commands/manager.ts";
+import type { WorkspaceContext } from "../index.ts";
+export declare class ReplPrompt {
+    private keypressListener?;
+    private rl;
+    private history;
+    private maxHistory;
+    private pasteCounter;
+    private pasteStore;
+    constructor({ commands, history, workspace, }: {
+        commands: CommandManager;
+        history: string[];
+        workspace: WorkspaceContext;
+    });
+    input(): Promise<string>;
+    getPasteStore(): Map<number, string>;
+    resetPasteStore(): void;
+    close(): void;
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=prompt.d.ts.map

package/dist/repl/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../source/repl/prompt.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAmKpD,qBAAa,UAAU;IAErB,OAAO,CAAC,gBAAgB,CAAC,CAAkC;IAC3D,OAAO,CAAC,EAAE,CAAY;IACtB,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,UAAU,CAA6B;gBAEnC,EACV,QAAQ,EACR,OAAO,EACP,SAAS,GACV,EAAE;QACD,QAAQ,EAAE,cAAc,CAAC;QACzB,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,SAAS,EAAE,gBAAgB,CAAC;KAC7B;IAwGK,KAAK;IAoBX,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIpC,eAAe,IAAI,IAAI;IAKvB,KAAK;IAQL,CAAC,MAAM,CAAC,OAAO,CAAC;CAGjB"}

package/dist/{repl-prompt.js → repl/prompt.js}

@@ -1,36 +1,82 @@
 import { readdir } from "node:fs/promises";
-import { parse, sep } from "node:path";
+import { parse, relative, resolve, sep } from "node:path";
 import { createInterface } from "node:readline/promises";
 import Clipboard from "@crosscopy/clipboard";
 import { asyncTry } from "@travisennis/stdlib/try";
-import { logger } from "./logger.js";
+import { logger } from "../logger.js";
 const whitespaceRegex = /\s+/;
-async function fileSystemCompleter(line) {
+// Cache for directory listings to improve performance
+class DirectoryCache {
+    cache = new Map();
+    ttl = 3000; // 3 seconds
+    async get(dir) {
+        const cached = this.cache.get(dir);
+        if (cached && Date.now() - cached.timestamp < this.ttl) {
+            return cached.entries;
+        }
+        return null;
+    }
+    set(dir, entries) {
+        this.cache.set(dir, { entries, timestamp: Date.now() });
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+const directoryCache = new DirectoryCache();
+// Helper function to get directory entries with caching
+async function getDirectoryEntries(dir) {
+    const cached = await directoryCache.get(dir);
+    if (cached) {
+        return cached;
+    }
+    const tryAttempt = await asyncTry(readdir(dir, { withFileTypes: true }));
+    if (tryAttempt.isFailure) {
+        return [];
+    }
+    const entries = tryAttempt.unwrap();
+    directoryCache.set(dir, entries);
+    return entries;
+}
+// Helper function to get completions from a specific directory
+async function getCompletionsFromDir(line, dir, workspace) {
     try {
         const words = line.split(" ");
         let last = words.at(-1);
         if (!last) {
-            return [[], line];
+            return [];
         }
         const isAt = last.startsWith("@");
         if (isAt) {
             last = last.slice(1);
         }
-        let { dir, base } = parse(last);
-        // If dir is empty, use current directory
-        if (!dir) {
-            dir = ".";
+        let { dir: pathDir, base } = parse(last);
+        // If pathDir is empty, use current directory
+        if (!pathDir) {
+            pathDir = ".";
+        }
+        // Resolve the path relative to the current directory
+        const resolvedPath = resolve(dir, pathDir);
+        // Check if resolved path is within any allowed directory
+        const isWithinAllowed = workspace.allowedDirs.some((allowedDir) => resolvedPath.startsWith(allowedDir));
+        if (!isWithinAllowed) {
+            return [];
         }
-        let tryAttempt = await asyncTry(readdir(dir, { withFileTypes: true }));
-        if (tryAttempt.isFailure) {
-            tryAttempt = await asyncTry(readdir(".", { withFileTypes: true }));
+        let dirEntries = await getDirectoryEntries(resolvedPath);
+        // If we couldn't read the directory, try current directory
+        if (dirEntries.length === 0 && pathDir !== ".") {
+            dirEntries = await getDirectoryEntries(dir);
+            pathDir = ".";
         }
-        let dirEntries = tryAttempt.unwrap();
-        // for an exact match that is a directory, read the contents of the directory
+        // For an exact match that is a directory, read the contents of the directory
         if (dirEntries.find((entry) => entry.name === base && entry.isDirectory())) {
-            dir = dir === "/" || dir === sep ? `${dir}${base}` : `${dir}/${base}`;
-            dirEntries = await readdir(dir, { withFileTypes: true });
+            const newPath = pathDir === "/" || pathDir === sep
+                ? `${pathDir}${base}`
+                : `${pathDir}/${base}`;
+            const newResolvedPath = resolve(dir, newPath);
+            dirEntries = await getDirectoryEntries(newResolvedPath);
             base = "";
+            pathDir = newPath;
         }
         else {
             dirEntries = dirEntries.filter((entry) => entry.name.startsWith(base));
@@ -38,10 +84,41 @@ async function fileSystemCompleter(line) {
         const hits = dirEntries
             .filter((entry) => entry.isFile() || entry.isDirectory())
             .map((entry) => {
-            const prefix = dir === "." ? "" : dir === sep || dir === "/" ? "" : `${dir}/`;
-            return `${isAt ? "@" : ""}${prefix}${entry.name}${entry.isDirectory() && !entry.name.endsWith("/") ? "/" : ""}`;
+            const prefix = pathDir === "."
+                ? ""
+                : pathDir === sep || pathDir === "/"
+                    ? ""
+                    : `${pathDir}/`;
+            const fullPath = `${prefix}${entry.name}${entry.isDirectory() && !entry.name.endsWith("/") ? "/" : ""}`;
+            // Convert to relative path from primary directory for display
+            const absolutePath = resolve(dir, fullPath);
+            const relativePath = relative(workspace.primaryDir, absolutePath);
+            return `${isAt ? "@" : ""}${relativePath.startsWith("..") ? relativePath : `./${relativePath}`}`;
         });
-        return [hits, `${isAt ? "@" : ""}${last}`];
+        return hits;
+    }
+    catch (_error) {
+        return [];
+    }
+}
+async function fileSystemCompleter(line, workspace) {
+    try {
+        const words = line.split(" ");
+        let last = words.at(-1);
+        if (!last) {
+            return [[], line];
+        }
+        const isAt = last.startsWith("@");
+        if (isAt) {
+            last = last.slice(1);
+        }
+        // Search all directories in parallel
+        const completionPromises = workspace.allowedDirs.map((dir) => getCompletionsFromDir(line, dir, workspace));
+        const allResults = await Promise.all(completionPromises);
+        const flattenedResults = allResults.flat();
+        // Remove duplicates while preserving order
+        const uniqueResults = [...new Set(flattenedResults)];
+        return [uniqueResults, `${isAt ? "@" : ""}${last}`];
     }
     catch (_error) {
         logger.error(_error);
@@ -54,7 +131,9 @@ export class ReplPrompt {
     rl;
     history;
     maxHistory = 25;
-    constructor({ commands, history, }) {
+    pasteCounter = 0;
+    pasteStore = new Map();
+    constructor({ commands, history, workspace, }) {
         this.history = history;
         this.rl = createInterface({
             input: process.stdin,
@@ -79,7 +158,7 @@ export class ReplPrompt {
                     (words.length === 1 || line.endsWith(" "))) {
                     return [matchingCommands, line];
                 }
-                return fileSystemCompleter(line); // [completions, line];
+                return fileSystemCompleter(line, workspace); // [completions, line];
             },
         });
         if (process.stdin.isTTY) {
@@ -99,11 +178,22 @@ export class ReplPrompt {
                             const cursorPos = this.rl.cursor;
                             const beforeCursor = currentLine.substring(0, cursorPos);
                             const afterCursor = currentLine.substring(cursorPos);
-                            const newLine = beforeCursor + clipboardText + afterCursor;
+                            let textToInsert;
+                            // Smart paste: use placeholder for text > 50 characters
+                            if (clipboardText.length > 50) {
+                                this.pasteCounter++;
+                                const pasteId = this.pasteCounter;
+                                this.pasteStore.set(pasteId, clipboardText);
+                                textToInsert = `[Paste #${pasteId}, ${clipboardText.length} characters]`;
+                            }
+                            else {
+                                textToInsert = clipboardText;
+                            }
+                            const newLine = beforeCursor + textToInsert + afterCursor;
                             // biome-ignore lint/suspicious/noExplicitAny: Accessing internal readline method
                             this.rl.line = newLine;
                             // biome-ignore lint/suspicious/noExplicitAny: Accessing internal readline method
-                            this.rl.cursor = cursorPos + clipboardText.length;
+                            this.rl.cursor = cursorPos + textToInsert.length;
                             // biome-ignore lint/suspicious/noExplicitAny: Accessing internal readline method
                             this.rl._refreshLine();
                         }
@@ -134,6 +224,13 @@ export class ReplPrompt {
         }
         return input;
     }
+    getPasteStore() {
+        return new Map(this.pasteStore);
+    }
+    resetPasteStore() {
+        this.pasteCounter = 0;
+        this.pasteStore.clear();
+    }
     close() {
         if (this.keypressListener) {
             process.stdin.off("keypress", this.keypressListener);

package/dist/repl/tool-call-repair.d.ts

@@ -0,0 +1,4 @@
+import { type ToolCallRepairFunction, type ToolSet } from "ai";
+import type { ModelManager } from "../models/manager.js";
+export declare const toolCallRepair: (modelManager: ModelManager) => ToolCallRepairFunction<ToolSet>;
+//# sourceMappingURL=tool-call-repair.d.ts.map

package/dist/repl/tool-call-repair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-repair.d.ts","sourceRoot":"","sources":["../../source/repl/tool-call-repair.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,OAAO,EACb,MAAM,IAAI,CAAC;AAIZ,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAoCzD,eAAO,MAAM,cAAc,GAAI,cAAc,YAAY,oCAmDxD,CAAC"}

package/dist/repl/tool-call-repair.js

@@ -0,0 +1,54 @@
+import { generateObject, NoSuchToolError, } from "ai";
+import { jsonrepair } from "jsonrepair";
+import { logger } from "../logger.js";
+async function remoteToolCallRepair(modelManager, toolCall, tool, inputSchema) {
+    const { object: repairedArgs } = await generateObject({
+        model: modelManager.getModel("tool-repair"),
+        schema: tool.inputSchema,
+        prompt: [
+            `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
+            JSON.stringify(toolCall.input),
+            "The tool accepts the following schema:",
+            JSON.stringify(inputSchema(toolCall)),
+            "Please fix the arguments.",
+        ].join("\n"),
+    });
+    return { ...toolCall, input: JSON.stringify(repairedArgs) };
+}
+const localToolCallRepair = async (toolCall, tool) => {
+    const schema = tool.inputSchema;
+    const repairedArgs = jsonrepair(toolCall.input);
+    const validatedArgs = schema.parse(JSON.parse(repairedArgs));
+    return { ...toolCall, input: JSON.stringify(validatedArgs) };
+};
+export const toolCallRepair = (modelManager) => {
+    const fn = async ({ toolCall, tools, inputSchema, error, }) => {
+        if (NoSuchToolError.isInstance(error)) {
+            return null;
+        }
+        logger.warn(`Attempting to repair tool call: ${toolCall.toolName}.`);
+        const tool = tools[toolCall.toolName];
+        if (typeof tool === "undefined") {
+            logger.error(new Error("Tool not found"), `Failed to repair tool call: ${toolCall.toolName}.`);
+            return null;
+        }
+        try {
+            const repaired = await localToolCallRepair(toolCall, tool);
+            logger.debug(`Tool call repaired with jsonrepair ${repaired.input}`);
+            return repaired;
+        }
+        catch (err) {
+            logger.error(err, `Failed to repair tool call locally: ${toolCall.toolName}.`);
+            try {
+                const repaired = await remoteToolCallRepair(modelManager, toolCall, tool, inputSchema);
+                logger.debug(`Tool call repaired with remote repair ${repaired.input}`);
+                return repaired;
+            }
+            catch (err2) {
+                logger.error(err2, `Failed to repair tool call remotely: ${toolCall.toolName}.`);
+                return null;
+            }
+        }
+    };
+    return fn;
+};