@travisennis/acai 0.0.9 → 0.0.11

package/dist/tools/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../source/tools/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAMF,QAAA,MAAM,WAAW;;;;iBAOf,CAAC;AAsBH,eAAO,MAAM,gBAAgB,GAAU,SAAS;IAC9C,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;gCAQoC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC;yCAIjC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,mBACrC,oBAAoB,KACpC,OAAO,CAAC,MAAM,CAAC;EAkDnB,CAAC"}

package/dist/tools/agent.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { SubAgent } from "../agent/sub-agent.js";
+import { isSupportedModel } from "../models/providers.js";
+import { environmentInfo } from "../prompts/system-prompt.js";
+import { getSubagent, loadSubagents } from "../subagents/index.js";
+import style from "../terminal/style.js";
+export const AgentTool = {
+    name: "Agent",
+};
+async function getToolDescription() {
+    return "Delegate a task to a specialized subagent.";
+}
+const inputSchema = z.object({
+    prompt: z.string().describe("The task for the agent to perform"),
+    type: z.string().describe("The subagent type to use (matches subagent name)"),
+    timeout: z
+        .number()
+        .optional()
+        .describe("Override default timeout in seconds"),
+});
+async function loadSubAgentDefinition(type) {
+    const subagent = await getSubagent(type);
+    if (!subagent) {
+        const available = await loadSubagents();
+        const names = available.map((s) => s.name).join(", ");
+        throw new Error(`Unknown subagent type: "${type}". Available: ${names}`);
+    }
+    return {
+        model: subagent.model ?? "",
+        system: subagent.systemPrompt,
+        tools: subagent.tools,
+        timeout: subagent.timeout,
+    };
+}
+export const createAgentTools = async (options) => {
+    const description = await getToolDescription();
+    const toolDef = {
+        description,
+        inputSchema,
+    };
+    function display({ prompt, type }) {
+        return `${style.cyan(type)} - ${style.dim(prompt.substring(0, 25))}`;
+    }
+    async function execute({ prompt, type, timeout }, { abortSignal }) {
+        if (abortSignal?.aborted) {
+            throw new Error("Agent execution aborted");
+        }
+        const { model, system, tools, timeout: defaultTimeout, } = await loadSubAgentDefinition(type);
+        const systemPrompt = `${system}
+
+${await environmentInfo(options.workspace.primaryDir, options.workspace.allowedDirs)}`;
+        const subagent = new SubAgent({ workspace: options.workspace });
+        const effectiveTimeout = timeout ?? defaultTimeout;
+        try {
+            const result = await subagent.execute({
+                model: isSupportedModel(model) ? model : "opencode:minimax-m2.5",
+                system: systemPrompt,
+                prompt,
+                abortSignal,
+                allowedTools: tools,
+                timeout: effectiveTimeout,
+            });
+            return result;
+        }
+        catch (error) {
+            const err = error;
+            const message = err.message || "Unknown error";
+            if (message.includes("timed out") ||
+                err.name === "AbortError" ||
+                err.name === "TimeoutError") {
+                return `Agent failed: ${message}. The timeout was ${effectiveTimeout} seconds. Consider increasing the timeout or breaking the task into smaller subtasks.`;
+            }
+            return `Agent failed: ${message}`;
+        }
+    }
+    return {
+        toolDef,
+        display,
+        execute,
+    };
+};

package/dist/tools/apply-patch.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
+import type { ToolExecutionOptions } from "./types.ts";
+export declare const ApplyPatchTool: {
+    name: "ApplyPatch";
+};
+declare const inputSchema: z.ZodObject<{
+    patchText: z.ZodString;
+}, z.core.$strip>;
+type ApplyPatchInputSchema = z.infer<typeof inputSchema>;
+export type Hunk = {
+    type: "add";
+    path: string;
+    contents: string;
+} | {
+    type: "delete";
+    path: string;
+} | {
+    type: "update";
+    path: string;
+    movePath?: string;
+    chunks: UpdateFileChunk[];
+};
+export interface UpdateFileChunk {
+    oldLines: string[];
+    newLines: string[];
+    changeContext?: string;
+    isEndOfFile?: boolean;
+}
+export type ApplyPatchFileChange = {
+    type: "add";
+    path: string;
+    content: string;
+} | {
+    type: "delete";
+    path: string;
+    content?: string;
+} | {
+    type: "update";
+    path: string;
+    unifiedDiff: string;
+    movePath?: string;
+    newContent: string;
+};
+export interface ParsedApplyPatch {
+    hunks: Hunk[];
+}
+export declare function parsePatch(patchText: string): ParsedApplyPatch;
+export declare const createApplyPatchTool: (options: {
+    workspace: WorkspaceContext;
+}) => Promise<{
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            patchText: z.ZodString;
+        }, z.core.$strip>;
+    };
+    display({ patchText }: ApplyPatchInputSchema): string;
+    execute({ patchText }: ApplyPatchInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
+}>;
+export {};
+//# sourceMappingURL=apply-patch.d.ts.map

package/dist/tools/apply-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-patch.d.ts","sourceRoot":"","sources":["../../source/tools/apply-patch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAOpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,cAAc;;CAE1B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAMf,CAAC;AAEH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAGzD,MAAM,MAAM,IAAI,GACZ;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChC;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B,CAAC;AAEN,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAClD;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEN,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AA+GD,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAsD9D;AAqMD,eAAO,MAAM,oBAAoB,GAAU,SAAS;IAClD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;2BAwB0B,qBAAqB;2BAU3B,qBAAqB,mBACnB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAiFrB,CAAC"}

package/dist/tools/apply-patch.js

@@ -0,0 +1,377 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { createTwoFilesPatch } from "diff";
+import { z } from "zod";
+import { config } from "../config/index.js";
+import { clearProjectStatusCache } from "../repl/project-status.js";
+import style from "../terminal/style.js";
+import { validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
+export const ApplyPatchTool = {
+    name: "ApplyPatch",
+};
+const inputSchema = z.object({
+    patchText: z
+        .string()
+        .describe("The full apply_patch text between *** Begin Patch and *** End Patch markers"),
+});
+// Patch parsing functions
+function parsePatchHeader(lines, startIdx) {
+    const line = lines[startIdx];
+    if (line.startsWith("*** Add File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+    }
+    if (line.startsWith("*** Delete File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+    }
+    if (line.startsWith("*** Update File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        let movePath;
+        let nextIdx = startIdx + 1;
+        if (nextIdx < lines.length && lines[nextIdx].startsWith("*** Move to:")) {
+            movePath = lines[nextIdx].split(":", 2)[1]?.trim();
+            nextIdx++;
+        }
+        return filePath ? { filePath, movePath, nextIdx } : null;
+    }
+    return null;
+}
+function parseUpdateFileChunks(lines, startIdx) {
+    const chunks = [];
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith("***")) {
+        if (lines[i].startsWith("@@")) {
+            const contextLine = lines[i].substring(2).trim();
+            i++;
+            const oldLines = [];
+            const newLines = [];
+            let isEndOfFile = false;
+            while (i < lines.length && !lines[i].startsWith("@@")) {
+                const changeLine = lines[i];
+                // Check for end of file marker first (before general *** check)
+                if (changeLine === "*** End of File") {
+                    isEndOfFile = true;
+                    i++;
+                    break;
+                }
+                // Check for other *** markers (new file operations)
+                if (changeLine.startsWith("***")) {
+                    break;
+                }
+                if (changeLine.startsWith(" ")) {
+                    const content = changeLine.substring(1);
+                    oldLines.push(content);
+                    newLines.push(content);
+                }
+                else if (changeLine.startsWith("-")) {
+                    oldLines.push(changeLine.substring(1));
+                }
+                else if (changeLine.startsWith("+")) {
+                    newLines.push(changeLine.substring(1));
+                }
+                i++;
+            }
+            chunks.push({
+                oldLines,
+                newLines,
+                changeContext: contextLine || undefined,
+                isEndOfFile: isEndOfFile || undefined,
+            });
+        }
+        else {
+            i++;
+        }
+    }
+    return { chunks, nextIdx: i };
+}
+function parseAddFileContent(lines, startIdx) {
+    let content = "";
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith("***")) {
+        if (lines[i].startsWith("+")) {
+            content += `${lines[i].substring(1)}\n`;
+        }
+        i++;
+    }
+    if (content.endsWith("\n"))
+        content = content.slice(0, -1);
+    return { content, nextIdx: i };
+}
+export function parsePatch(patchText) {
+    const lines = patchText.split("\n");
+    const hunks = [];
+    const beginMarker = "*** Begin Patch";
+    const endMarker = "*** End Patch";
+    const beginIdx = lines.findIndex((l) => l.trim() === beginMarker);
+    const endIdx = lines.findIndex((l) => l.trim() === endMarker);
+    if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
+        throw new Error("Invalid patch format: missing Begin/End markers");
+    }
+    let i = beginIdx + 1;
+    while (i < endIdx) {
+        const header = parsePatchHeader(lines, i);
+        if (!header) {
+            i++;
+            continue;
+        }
+        if (lines[i].startsWith("*** Add File:")) {
+            const { content, nextIdx } = parseAddFileContent(lines, header.nextIdx);
+            hunks.push({ type: "add", path: header.filePath, contents: content });
+            i = nextIdx;
+            continue;
+        }
+        if (lines[i].startsWith("*** Delete File:")) {
+            hunks.push({ type: "delete", path: header.filePath });
+            i = header.nextIdx;
+            continue;
+        }
+        if (lines[i].startsWith("*** Update File:")) {
+            const { chunks: parsedChunks, nextIdx } = parseUpdateFileChunks(lines, header.nextIdx);
+            hunks.push({
+                type: "update",
+                path: header.filePath,
+                movePath: header.movePath,
+                chunks: parsedChunks,
+            });
+            i = nextIdx;
+            continue;
+        }
+        i++;
+    }
+    return { hunks };
+}
+function resolvePathInRoot(rootAbs, p) {
+    // Relative paths are resolved against rootAbs
+    // Absolute paths are used as-is (but validated later)
+    const abs = path.isAbsolute(p) ? path.normalize(p) : path.resolve(rootAbs, p);
+    const rel = path.relative(rootAbs, abs) || ".";
+    return { abs, rel };
+}
+function seekSequence(lines, pattern, startIndex) {
+    if (pattern.length === 0)
+        return -1;
+    for (let i = startIndex; i <= lines.length - pattern.length; i++) {
+        let matches = true;
+        for (let j = 0; j < pattern.length; j++) {
+            if (lines[i + j] !== pattern[j]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return i;
+    }
+    return -1;
+}
+function applyReplacements(lines, replacements) {
+    const result = [...lines];
+    for (let i = replacements.length - 1; i >= 0; i--) {
+        const [startIdx, oldLen, newSegment] = replacements[i];
+        result.splice(startIdx, oldLen);
+        for (let j = 0; j < newSegment.length; j++)
+            result.splice(startIdx + j, 0, newSegment[j]);
+    }
+    return result;
+}
+function computeReplacements(originalLines, filePath, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        if (chunk.changeContext) {
+            const contextIdx = seekSequence(originalLines, [chunk.changeContext], lineIndex);
+            if (contextIdx === -1) {
+                throw new Error(`Failed to find context '${chunk.changeContext}' in ${filePath}`);
+            }
+            lineIndex = contextIdx + 1;
+        }
+        if (chunk.oldLines.length === 0) {
+            const insertionIdx = originalLines.length > 0 &&
+                originalLines[originalLines.length - 1] === ""
+                ? originalLines.length - 1
+                : originalLines.length;
+            replacements.push([insertionIdx, 0, chunk.newLines]);
+            continue;
+        }
+        let pattern = chunk.oldLines;
+        let newSlice = chunk.newLines;
+        let found = seekSequence(originalLines, pattern, lineIndex);
+        if (found === -1 &&
+            pattern.length > 0 &&
+            pattern[pattern.length - 1] === "") {
+            pattern = pattern.slice(0, -1);
+            if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "")
+                newSlice = newSlice.slice(0, -1);
+            found = seekSequence(originalLines, pattern, lineIndex);
+        }
+        if (found !== -1) {
+            replacements.push([found, pattern.length, newSlice]);
+            lineIndex = found + pattern.length;
+        }
+        else {
+            throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.oldLines.join("\n")}`);
+        }
+    }
+    replacements.sort((a, b) => a[0] - b[0]);
+    return replacements;
+}
+function generateUnifiedDiff(oldContent, newContent, filePath) {
+    return createTwoFilesPatch(filePath, filePath, oldContent, newContent, "original", "modified");
+}
+function deriveNewContentsFromChunks(fileAbsPath, chunks) {
+    let originalContent;
+    try {
+        originalContent = fs.readFileSync(fileAbsPath, "utf-8");
+    }
+    catch (error) {
+        throw new Error(`Failed to read file ${fileAbsPath}: ${String(error)}`);
+    }
+    const originalLines = originalContent.split("\n");
+    if (originalLines.length > 0 &&
+        originalLines[originalLines.length - 1] === "")
+        originalLines.pop();
+    const replacements = computeReplacements(originalLines, fileAbsPath, chunks);
+    const newLines = applyReplacements(originalLines, replacements);
+    // ensure trailing newline
+    if (newLines.length === 0 || newLines[newLines.length - 1] !== "")
+        newLines.push("");
+    const newContent = newLines.join("\n");
+    return {
+        unifiedDiff: generateUnifiedDiff(originalContent, newContent, fileAbsPath),
+        content: newContent,
+    };
+}
+async function applyChanges(changes, signal) {
+    const changed = [];
+    for (const change of changes) {
+        if (signal?.aborted)
+            throw new Error("Cancelled");
+        if (change.type === "add") {
+            const dir = path.dirname(change.path);
+            if (dir !== "." && dir !== "/")
+                await fsp.mkdir(dir, { recursive: true });
+            await fsp.writeFile(change.path, change.content, "utf-8");
+            changed.push(change.path);
+            continue;
+        }
+        if (change.type === "delete") {
+            await fsp.unlink(change.path).catch(() => { });
+            changed.push(change.path);
+            continue;
+        }
+        // update
+        if (change.movePath) {
+            const dir = path.dirname(change.movePath);
+            if (dir !== "." && dir !== "/")
+                await fsp.mkdir(dir, { recursive: true });
+            await fsp.writeFile(change.movePath, change.newContent, "utf-8");
+            await fsp.unlink(change.path).catch(() => { });
+            changed.push(change.movePath);
+            continue;
+        }
+        await fsp.writeFile(change.path, change.newContent, "utf-8");
+        changed.push(change.path);
+    }
+    return changed;
+}
+export const createApplyPatchTool = async (options) => {
+    const { primaryDir, allowedDirs } = options.workspace;
+    const allowedDirectories = allowedDirs ?? [primaryDir];
+    const projectConfig = await config.getConfig();
+    return {
+        toolDef: {
+            description: "Apply a high-level apply_patch diff to modify files.\n\n" +
+                "Input must be in the apply_patch format surrounded by markers:\n\n" +
+                "*** Begin Patch\n" +
+                "*** Update File: path/to/file\n" +
+                "@@ optional context line\n" +
+                " unchanged line\n" +
+                "- removed line\n" +
+                "+ added line\n" +
+                "*** End Patch\n\n" +
+                "Supported operations:\n" +
+                "- *** Add File: path/to/file (content lines prefixed with +)\n" +
+                "- *** Update File (with optional *** Move to: new/path)\n" +
+                "- *** Delete File: path/to/file\n\n" +
+                "File paths may be absolute or relative to the project directory.",
+            inputSchema,
+        },
+        display({ patchText }) {
+            // Extract number of files being modified from patch text
+            try {
+                const { hunks } = parsePatch(patchText);
+                return `${style.cyan("apply patch")} (${hunks.length} file${hunks.length === 1 ? "" : "s"})`;
+            }
+            catch {
+                return `${style.cyan("apply patch")}`;
+            }
+        },
+        async execute({ patchText }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("Apply patch aborted");
+            }
+            const root = path.resolve(primaryDir);
+            const { hunks } = parsePatch(patchText);
+            if (hunks.length === 0) {
+                return "No changes found in patch.";
+            }
+            // Build a list of resolved file changes (absolute paths), and a diff preview.
+            const changes = [];
+            let diffOutput = "";
+            for (const hunk of hunks) {
+                if (abortSignal?.aborted)
+                    throw new Error("Cancelled");
+                const p = resolvePathInRoot(root, hunk.path);
+                // Validate path is within allowed directories
+                const validPath = await validatePath(p.abs, allowedDirectories, {
+                    requireExistence: hunk.type !== "add",
+                    abortSignal,
+                });
+                if (hunk.type === "add") {
+                    changes.push({
+                        type: "add",
+                        path: validPath,
+                        content: hunk.contents,
+                    });
+                    continue;
+                }
+                if (hunk.type === "delete") {
+                    // Validate file is not read-only before deletion
+                    validateFileNotReadOnly(validPath, projectConfig, primaryDir);
+                    changes.push({ type: "delete", path: validPath });
+                    continue;
+                }
+                // update - validate file is not read-only
+                validateFileNotReadOnly(validPath, projectConfig, primaryDir);
+                let moveAbs;
+                if (hunk.movePath) {
+                    const moveP = resolvePathInRoot(root, hunk.movePath);
+                    moveAbs = await validatePath(moveP.abs, allowedDirectories, {
+                        requireExistence: false,
+                        abortSignal,
+                    });
+                }
+                const upd = deriveNewContentsFromChunks(validPath, hunk.chunks);
+                changes.push({
+                    type: "update",
+                    path: validPath,
+                    movePath: moveAbs,
+                    newContent: upd.content,
+                    unifiedDiff: upd.unifiedDiff,
+                });
+                if (upd.unifiedDiff) {
+                    diffOutput += `*** Update File: ${path.relative(root, moveAbs ?? validPath)}\n`;
+                    diffOutput += `${upd.unifiedDiff}\n`;
+                }
+            }
+            // Apply changes
+            const changedAbs = await applyChanges(changes, abortSignal);
+            const changedRel = changedAbs.map((p) => path.relative(root, p));
+            clearProjectStatusCache();
+            const summary = `${changedRel.length} file(s) changed`;
+            const filesList = changedRel.map((x) => `  ${x}`).join("\n");
+            return `Patch applied successfully. ${summary}\n${filesList}\n\n${diffOutput}`;
+        },
+    };
+};

package/dist/tools/bash.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
 import type { ToolExecutionOptions } from "./types.ts";
 export declare const BashTool: {
     name: "Bash";
@@ -10,9 +11,9 @@ declare const inputSchema: z.ZodObject<{
     background: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type BashInputSchema = z.infer<typeof inputSchema>;
-export declare const createBashTool: ({ baseDir, allowedDirs, }: {
-    baseDir: string;
-    allowedDirs?: string[];
+export declare const createBashTool: (options: {
+    workspace: WorkspaceContext;
+    env?: Record<string, string>;
 }) => Promise<{
     toolDef: {
         description: string;

package/dist/tools/bash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/tools/bash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAqCvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAYF,QAAA,MAAM,WAAW;;;;;iBAkBf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc,GAAU,2BAGlC;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;yBAQwB,eAAe;mDAIK,eAAe,mBACrC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAgGrB,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/tools/bash.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAUpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA0CvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AA4MF,QAAA,MAAM,WAAW;;;;;iBAkBf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc,GAAU,SAAS;IAC5C,SAAS,EAAE,gBAAgB,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;;;;;;;;;;yBA2FwB,eAAe;mDAIK,eAAe,mBACrC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6BrB,CAAC"}