@travisennis/acai 0.0.4 → 0.0.6

package/dist/tools/code-interpreter.js

@@ -3,229 +3,165 @@ import { randomUUID } from "node:crypto";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import process from "node:process";
-import { tool } from "ai";
 import { z } from "zod";
+import { manageTokenLimit } from "../tokens/threshold.js";
 export const CodeInterpreterTool = {
     name: "codeInterpreter",
 };
-const toolDescription = `Executes JavaScript or Typescript code in a separate Node.js process using Node's Permission Model. 
-
-⚠️ **IMPORTANT TYPE SELECTION**:
-- Use "JavaScript" for plain JavaScript code (no TypeScript syntax)
-- Use "Typescript" for code containing interfaces, type annotations, generics, etc.
-- Code type is automatically validated before execution
+const toolDescription = `Executes Typescript code in a separate Node.js process using Node's Permission Model. 
 
 ⚠️ **IMPORTANT**: This tool uses ES Modules (ESM) only.
 - Use \`import\` statements, NOT \`require()\`
 - Examples: \`import fs from 'node:fs'\` NOT \`const fs = require('fs')\`
 - Add file extensions for relative imports: \`import { utils } from './utils.js'\`
 
-These scripts are run in the \`${process.cwd}/.acai-ci-tmp\`. Keep this in mind if you intend to import or reference files from this project in your script.
+These scripts are run in the \`${process.cwd()}/.acai-ci-tmp\`. You can import project source files using relative paths from the project root with .ts extensions:
 
-Timeout defaults to 5 seconds and can be extended up to 60 seconds.`;
-/**
- * Detects if code contains TypeScript syntax patterns
- */
-function containsTypeScriptSyntax(code) {
-    // Common TypeScript patterns that don't exist in JavaScript
-    const tsPatterns = [
-        // Type annotations
-        /:\s*[a-zA-Z]\w*(?:\s*\[])?\s*(?=[,;=)])/g, // Type annotations after variables/parameters (including any, string[], etc.)
-        /:\s*\{[^}]*\}\s*(?=[,;=)])/g, // Object type annotations
-        /:\s*\([^)]*\)\s*=>/g, // Function type annotations
-        // Type declarations
-        /^\s*interface\s+\w+/gm, // Interface declarations
-        /^\s*type\s+\w+\s*=/gm, // Type aliases
-        /^\s*enum\s+\w+/gm, // Enum declarations
-        // Generic types
-        /<\s*[A-Z]\w*(?:\s*,\s*[A-Z]\w*)*\s*>/g, // Generic type parameters
-        /\w+\s*<\s*[^<>]+?\s*>/g, // Generic type usage
-        // TypeScript-specific keywords (in specific contexts)
-        /\b(?:implements|extends\s+[A-Z]\w*|readonly|private|protected|public)\b/g,
-        // Utility types
-        /\b(?:Partial|Required|Pick|Omit|Record|Exclude|Extract)\b/g,
-    ];
-    return tsPatterns.some((pattern) => pattern.test(code));
-}
-/**
- * Validates that code content matches the specified type
- */
-function validateCodeTypeMatch(code, specifiedType) {
-    if (!code?.trim()) {
-        return "No code provided";
-    }
-    const detectedType = containsTypeScriptSyntax(code)
-        ? "Typescript"
-        : "JavaScript";
-    const expectedType = specifiedType ?? "JavaScript";
-    // If TypeScript syntax detected but JavaScript specified
-    if (detectedType === "Typescript" && expectedType === "JavaScript") {
-        return `Code contains TypeScript syntax but is specified as JavaScript. Please either:
-1. Change type to "Typescript", or
-2. Remove TypeScript syntax (interfaces, type annotations, generics, etc.)
+\`\`\` typescript
+import { functionName } from '../source/path/to/module.ts';
+\`\`\`
 
-Detected TypeScript patterns: ${getTypeScriptPatternsFound(code).join(", ")}`;
-    }
-    // If no TypeScript syntax but TypeScript specified (warning, not error)
-    if (detectedType === "JavaScript" && expectedType === "Typescript") {
-        // This is not an error, just potentially unnecessary
-        return null;
-    }
-    return null;
-}
-/**
- * Identifies specific TypeScript patterns found in code
- */
-function getTypeScriptPatternsFound(code) {
-    const patterns = [];
-    if (/\binterface\s+\w+/.test(code))
-        patterns.push("interface");
-    if (/\btype\s+\w+\s*=/.test(code))
-        patterns.push("type alias");
-    if (/:\s*[a-zA-Z]\w*(?:\s*\[])?\s*(?=[,;=)])/g.test(code))
-        patterns.push("type annotations");
-    if (/<\s*[A-Z]\w*\s*>/.test(code))
-        patterns.push("generics");
-    if (/\benum\s+\w+/.test(code))
-        patterns.push("enum");
-    return patterns;
-}
-export const createCodeInterpreterTool = ({ sendData, }) => {
-    return {
-        [CodeInterpreterTool.name]: tool({
-            description: toolDescription,
-            inputSchema: z.object({
-                code: z
-                    .string()
-                    .describe("The JavaScript or Typescript code to be executed."),
-                type: z
-                    .enum(["JavaScript", "Typescript"])
-                    .nullable()
-                    .describe("The type of code. Either Javascript or Typescript."),
-                timeoutSeconds: z
-                    .number()
-                    .int()
-                    .min(1)
-                    .max(60)
-                    .nullable()
-                    .describe("Execution timeout in seconds (1-60). Default 5."),
-            }),
-            execute: async ({ code, type, timeoutSeconds }, { toolCallId }) => {
-                const workingDirectory = process.cwd();
-                try {
-                    // Pre-execution validation
-                    const validationError = validateCodeTypeMatch(code, type);
-                    if (validationError) {
-                        sendData?.({
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: validationError,
-                        });
-                        return validationError;
-                    }
-                    sendData?.({
-                        event: "tool-init",
-                        id: toolCallId,
-                        data: "Initializing code interpreter environment",
-                    });
-                    const scriptType = (type ?? "JavaScript").toLowerCase();
-                    sendData?.({
-                        event: "tool-update",
-                        id: toolCallId,
-                        data: {
-                            primary: "Executing...",
-                            secondary: [
-                                `${"`".repeat(3)} ${scriptType}}\n${code.slice(0, 500)}${"`".repeat(3)}`,
-                            ],
-                        },
-                    });
-                    if (code.trim().length === 0) {
-                        throw new Error("No code provided");
-                    }
-                    const timeoutMs = Math.min(Math.max((timeoutSeconds ?? 5) * 1000, 1000), 60000);
-                    const tmpBase = join(workingDirectory, ".acai-ci-tmp");
-                    await mkdir(tmpBase, { recursive: true });
-                    const ext = type === "JavaScript" ? ".mjs" : ".ts";
-                    const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}${ext}`);
-                    await writeFile(scriptPath, code, { encoding: "utf8" });
-                    const args = [
-                        "--permission",
-                        `--allow-fs-read=${workingDirectory}`,
-                        `--allow-fs-write=${workingDirectory}`,
-                        scriptPath,
-                    ];
-                    const child = spawn(process.execPath, args, {
-                        cwd: workingDirectory,
-                        // do not rely solely on spawn's timeout; we implement manual timeout below
-                        stdio: "pipe",
-                        env: Object.assign({}, process.env, {
-                            // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                            NO_COLOR: "true",
-                            // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                            NODE_OPTIONS: "",
-                        }),
-                    });
-                    let stdout = "";
-                    let stderr = "";
-                    let timedOut = false;
-                    const timer = setTimeout(() => {
-                        timedOut = true;
-                        try {
-                            child.kill("SIGKILL");
-                        }
-                        catch { }
-                    }, timeoutMs);
-                    child.stdout.setEncoding("utf8");
-                    child.stderr.setEncoding("utf8");
-                    child.stdout.on("data", (chunk) => {
-                        stdout += String(chunk);
-                    });
-                    child.stderr.on("data", (chunk) => {
-                        stderr += String(chunk);
-                    });
-                    const completed = await new Promise((resolve, reject) => {
-                        child.on("error", (err) => reject(err));
-                        child.on("close", (code, signal) => resolve({ code, signal }));
-                    });
-                    clearTimeout(timer);
-                    // Cleanup temp file/directory
-                    await rm(scriptPath, { force: true });
-                    await rm(tmpBase, { force: true, recursive: true });
-                    if (timedOut) {
-                        throw new Error("Script timed out");
-                    }
-                    if (completed.code === null) {
-                        throw new Error(`Process terminated by signal ${completed.signal ?? "unknown"}`);
-                    }
-                    if (completed.code !== 0) {
-                        const message = `Process exited with code ${completed.code}. Stderr: ${stderr.trim()}`;
-                        throw new Error(message);
+The interpreter supports ES Modules with TypeScript files directly.
+
+Timeout defaults to 5 seconds and can be extended up to 60 seconds.`;
+const inputSchema = z.object({
+    code: z.string().describe("The Typescript code to be executed."),
+    timeoutSeconds: z
+        .number()
+        .int()
+        .min(1)
+        .max(60)
+        .nullable()
+        .describe("Execution timeout in seconds (1-60). Default 5."),
+});
+export const createCodeInterpreterTool = async ({ tokenCounter, }) => {
+    const toolDef = {
+        description: toolDescription,
+        inputSchema,
+    };
+    async function* execute({ code, timeoutSeconds }, { toolCallId, abortSignal }) {
+        // Check if execution has been aborted
+        if (abortSignal?.aborted) {
+            throw new Error("Code interpretation aborted");
+        }
+        const workingDirectory = process.cwd();
+        const lines = code.split("\n");
+        try {
+            yield {
+                name: CodeInterpreterTool.name,
+                event: "tool-init",
+                id: toolCallId,
+                data: `Executing ${lines.length} lines of code.`,
+            };
+            if (code.trim().length === 0) {
+                throw new Error("No code provided");
+            }
+            if (abortSignal?.aborted) {
+                throw new Error("Code interpretation aborted before execution");
+            }
+            const timeoutMs = Math.min(Math.max((timeoutSeconds ?? 5) * 1000, 1000), 60000);
+            const tmpBase = join(workingDirectory, ".acai-ci-tmp");
+            await mkdir(tmpBase, { recursive: true });
+            const ext = ".ts";
+            const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}${ext}`);
+            await writeFile(scriptPath, code, { encoding: "utf8" });
+            const args = [
+                "--permission",
+                `--allow-fs-read=${workingDirectory}`,
+                `--allow-fs-write=${workingDirectory}`,
+                scriptPath,
+            ];
+            const child = spawn(process.execPath, args, {
+                cwd: workingDirectory,
+                // do not rely solely on spawn's timeout; we implement manual timeout below
+                stdio: "pipe",
+                env: Object.assign({}, process.env, {
+                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+                    NO_COLOR: "true",
+                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+                    NODE_OPTIONS: "",
+                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+                    ACAI_CODE_INTERPRETER: "true",
+                }),
+            });
+            // Handle abort signal by killing the child process
+            if (abortSignal) {
+                const abortHandler = () => {
+                    try {
+                        child.kill("SIGKILL");
                     }
-                    const result = {
-                        stdout: stdout.trim(),
-                        stderr: stderr.trim(),
-                        exitCode: completed.code ?? -1,
-                    };
-                    sendData?.({
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: "Code execution completed successfully",
-                    });
-                    return JSON.stringify(result, null, 2);
-                }
-                catch (err) {
-                    const errorMessage = err.name === "ETIMEDOUT" ||
-                        err.message.includes("timed out")
-                        ? "Script timed out"
-                        : `Error: ${err.message}`;
-                    sendData?.({
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: errorMessage,
-                    });
-                    return errorMessage;
+                    catch { }
+                    throw new Error("Code interpretation aborted during execution");
+                };
+                abortSignal.addEventListener("abort", abortHandler);
+            }
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                try {
+                    child.kill("SIGKILL");
                 }
-            },
-        }),
+                catch { }
+            }, timeoutMs);
+            child.stdout.setEncoding("utf8");
+            child.stderr.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                stdout += String(chunk);
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += String(chunk);
+            });
+            const completed = await new Promise((resolve, reject) => {
+                child.on("error", (err) => reject(err));
+                child.on("close", (code, signal) => resolve({ code, signal }));
+            });
+            clearTimeout(timer);
+            // Cleanup temp file/directory
+            await rm(scriptPath, { force: true });
+            await rm(tmpBase, { force: true, recursive: true });
+            if (timedOut) {
+                throw new Error("Script timed out");
+            }
+            if (completed.code === null) {
+                throw new Error(`Process terminated by signal ${completed.signal ?? "unknown"}`);
+            }
+            if (completed.code !== 0) {
+                const message = `Process exited with code ${completed.code}. Stderr:\n${stderr.trim()}`;
+                throw new Error(message);
+            }
+            const result = {
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                exitCode: completed.code ?? -1,
+            };
+            const resultJson = JSON.stringify(result, null, 2);
+            const managedResult = await manageTokenLimit(resultJson, tokenCounter, "CodeInterpreter", "Reduce script complexity or output size");
+            yield {
+                name: CodeInterpreterTool.name,
+                event: "tool-completion",
+                id: toolCallId,
+                data: `Completed successfully${managedResult.tokenCount > 0 ? ` (${managedResult.tokenCount} tokens)` : ""}`,
+            };
+            yield managedResult.content;
+        }
+        catch (err) {
+            const errorMessage = err.name === "ETIMEDOUT" ||
+                err.message.includes("timed out")
+                ? "Script timed out"
+                : err.message;
+            yield {
+                name: CodeInterpreterTool.name,
+                event: "tool-error",
+                id: toolCallId,
+                data: errorMessage,
+            };
+            yield errorMessage;
+        }
+    }
+    return {
+        toolDef,
+        execute,
     };
 };

package/dist/tools/delete-file.d.ts

@@ -1,15 +1,24 @@
-import type { Terminal } from "../terminal/index.ts";
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { ToolResult } from "./types.ts";
 export declare const DeleteFileTool: {
     name: "deleteFile";
 };
-export declare const createDeleteFileTool: ({ workingDir, sendData, terminal, autoAcceptAll, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+type DeleteFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createDeleteFileTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
-    sendData?: SendData;
-    terminal?: Terminal;
-    autoAcceptAll?: boolean;
+    allowedDirs?: string[];
 }) => Promise<{
-    deleteFile: import("ai").Tool<{
-        path: string;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute({ path: userPath }: DeleteFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
+//# sourceMappingURL=delete-file.d.ts.map

package/dist/tools/delete-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-file.d.ts","sourceRoot":"","sources":["../../source/tools/delete-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,cAAc;;CAE1B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEzD,eAAO,MAAM,oBAAoB,GAAU,8BAGxC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;gCASyB,qBAAqB,+BACZ,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EA2DhC,CAAC"}

package/dist/tools/delete-file.js

@@ -1,100 +1,70 @@
 import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
-import { input, select } from "@inquirer/prompts";
-import { tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
+import style from "../terminal/style.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const DeleteFileTool = {
     name: "deleteFile",
 };
-export const createDeleteFileTool = async ({ workingDir, sendData, terminal, autoAcceptAll, }) => {
-    const allowedDirectory = workingDir;
-    let autoAcceptDeletes = autoAcceptAll ?? false;
+const inputSchema = z.object({
+    path: z.string().describe("Absolute path to the file to delete"),
+});
+export const createDeleteFileTool = async ({ workingDir, allowedDirs, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [DeleteFileTool.name]: tool({
+        toolDef: {
             description: "Delete a file permanently.",
-            inputSchema: z.object({
-                path: z.string().describe("Absolute path to the file to delete"),
-            }),
-            execute: async ({ path: userPath }, { toolCallId }) => {
-                sendData?.({
+            inputSchema,
+        },
+        async *execute({ path: userPath }, { toolCallId, abortSignal }) {
+            try {
+                if (abortSignal?.aborted) {
+                    throw new Error("File deletion aborted");
+                }
+                yield {
+                    name: DeleteFileTool.name,
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Deleting file: ${chalk.cyan(userPath)}`,
-                });
-                try {
-                    const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory);
-                    // Check if file exists before attempting delete
-                    if (!existsSync(filePath)) {
-                        throw new Error(`File not found: ${filePath}`);
-                    }
-                    // Ensure it's a file, not a directory
-                    const stats = await fs.stat(filePath);
-                    if (stats.isDirectory()) {
-                        throw new Error(`Path is a directory, not a file: ${filePath}`);
-                    }
-                    if (terminal) {
-                        terminal.writeln(`\n${chalk.red.bold("●")} Proposing file deletion: ${chalk.cyan(userPath)}`);
-                        terminal.lineBreak();
-                        terminal.writeln("This action cannot be undone.");
-                        terminal.lineBreak();
-                        let userChoice;
-                        if (autoAcceptDeletes) {
-                            terminal.writeln(chalk.green("✓ Auto-accepting deletions (all future deletions will be accepted)"));
-                            userChoice = "accept";
-                        }
-                        else {
-                            userChoice = await select({
-                                message: "What would you like to do with this file?",
-                                choices: [
-                                    { name: "Accept and delete this file", value: "accept" },
-                                    {
-                                        name: "Accept all future deletions (including this)",
-                                        value: "accept-all",
-                                    },
-                                    { name: "Reject this deletion", value: "reject" },
-                                ],
-                                default: "accept",
-                            });
-                        }
-                        terminal.lineBreak();
-                        if (userChoice === "accept-all") {
-                            autoAcceptDeletes = true;
-                            terminal.writeln(chalk.yellow("✓ Auto-accept mode enabled for all future deletions"));
-                            terminal.lineBreak();
-                        }
-                        if (userChoice === "reject") {
-                            const reason = await input({ message: "Feedback: " });
-                            terminal.lineBreak();
-                            sendData?.({
-                                id: toolCallId,
-                                event: "tool-completion",
-                                data: `Deletion rejected by user. Reason: ${reason}`,
-                            });
-                            return `The user rejected this deletion. Reason: ${reason}`;
-                        }
-                        // If accepted, proceed to delete file
-                    }
-                    // Delete the file
-                    await fs.unlink(filePath);
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: "File deleted successfully",
-                    });
-                    return `Successfully deleted ${filePath}`;
+                    data: `${style.cyan(userPath)}`,
+                };
+                const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { abortSignal });
+                // Check if file exists before attempting delete
+                if (!existsSync(filePath)) {
+                    throw new Error(`File not found: ${filePath}`);
+                }
+                // Pre-check for stat
+                if (abortSignal?.aborted) {
+                    throw new Error("File deletion aborted before stat");
+                }
+                // Ensure it's a file, not a directory
+                const stats = await fs.stat(filePath);
+                if (stats.isDirectory()) {
+                    throw new Error(`Path is a directory, not a file: ${filePath}`);
                 }
-                catch (error) {
-                    const errorMessage = `Failed to delete file: ${error.message}`;
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-error",
-                        data: errorMessage,
-                    });
-                    return errorMessage;
+                // Pre-side-effect check
+                if (abortSignal?.aborted) {
+                    throw new Error("File deletion aborted before unlink");
                 }
-            },
-        }),
+                // Delete the file with signal
+                await fs.unlink(filePath);
+                yield {
+                    name: DeleteFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: "File deleted",
+                };
+                yield `Successfully deleted ${filePath}`;
+            }
+            catch (error) {
+                const errorMessage = error.message;
+                yield {
+                    name: DeleteFileTool.name,
+                    id: toolCallId,
+                    event: "tool-error",
+                    data: errorMessage,
+                };
+                yield errorMessage;
+            }
+        },
     };
 };

package/dist/tools/directory-tree.d.ts

@@ -1,12 +1,32 @@
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { ToolResult } from "./types.ts";
 export declare const DirectoryTreeTool: {
     name: "directoryTree";
 };
-export declare const createDirectoryTreeTool: ({ workingDir, sendData, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+type DirectoryTreeInputSchema = z.infer<typeof inputSchema>;
+export declare const createDirectoryTreeTool: ({ workingDir, allowedDirs, tokenCounter, }: {
     workingDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
+    tokenCounter: TokenCounter;
 }) => Promise<{
-    directoryTree: import("ai").Tool<{
-        path: string;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute({ path }: DirectoryTreeInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+/**
+ * Generates a string representation of a directory tree starting from the given path.
+ * @param dirPath - The path of the directory to generate the tree for.
+ * @returns A Promise that resolves to a string representation of the directory tree.
+ */
+export declare function directoryTree(dirPath: string): Promise<string>;
+export {};
+//# sourceMappingURL=directory-tree.d.ts.map

package/dist/tools/directory-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,4CAI3C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;sBASe,wBAAwB,+BACL,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EA+DhC,CAAC;AA8CF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAYpE"}