@travisennis/acai 0.0.4 → 0.0.5

package/dist/tools/save-file.js

@@ -1,20 +1,20 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { input, select } from "@inquirer/prompts";
 import { tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
+import { formatCodeBlock } from "../formatting.js";
+import style from "../terminal/style.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 import { fileEncodingSchema } from "./types.js";
 export const SaveFileTool = {
     name: "saveFile",
 };
-export const createSaveFileTool = async ({ workingDir, sendData, terminal, autoAcceptAll, }) => {
+export const createSaveFileTool = async ({ workingDir, terminal, sendData, toolExecutor, }) => {
     const allowedDirectory = workingDir;
-    let autoAcceptSaves = autoAcceptAll ?? false;
     return {
         [SaveFileTool.name]: tool({
             description: "Create a new file or completely overwrite an existing file with new content. " +
+                "Automatically creates all missing parent directories. " +
                 "Use with caution as it will overwrite existing files without warning. " +
                 "Handles text content with proper encoding. Only works within allowed directories.",
             inputSchema: z.object({
@@ -22,61 +22,89 @@ export const createSaveFileTool = async ({ workingDir, sendData, terminal, autoA
                 content: z.string().describe("Content to save in the file"),
                 encoding: fileEncodingSchema.describe('Encoding format for saving the file. Use "utf-8" as default for text files'),
             }),
-            execute: async ({ path: userPath, content, encoding, }, { toolCallId }) => {
+            execute: async ({ path: userPath, content, encoding, }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("File saving aborted");
+                }
                 sendData?.({
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Saving file: ${chalk.cyan(userPath)}`,
+                    data: `Saving file: ${style.cyan(userPath)}`,
                 });
                 try {
-                    const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory);
+                    const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
                     if (terminal) {
-                        terminal.writeln(`\n${chalk.blue.bold("●")} Proposing file save: ${chalk.cyan(userPath)}`);
+                        terminal.writeln(`\n${style.blue.bold("●")} Proposing file save: ${style.cyan(userPath)}`);
                         terminal.lineBreak();
                         terminal.writeln("Proposed file content:");
-                        terminal.lineBreak();
-                        terminal.display(content);
-                        terminal.lineBreak();
-                        let userChoice;
-                        if (autoAcceptSaves) {
-                            terminal.writeln(chalk.green("✓ Auto-accepting saves (all future saves will be accepted)"));
-                            userChoice = "accept";
+                        terminal.hr();
+                        terminal.display(formatCodeBlock(userPath, content));
+                        terminal.hr();
+                        // Determine overwrite status for display
+                        let overwriteMessage = "";
+                        try {
+                            const stat = await fs.stat(filePath);
+                            if (stat.isFile()) {
+                                overwriteMessage = style.yellow("(Will overwrite existing file)");
+                            }
                         }
-                        else {
-                            userChoice = await select({
-                                message: "What would you like to do with this file?",
-                                choices: [
-                                    { name: "Accept and save this file", value: "accept" },
-                                    {
-                                        name: "Accept all future saves (including this)",
-                                        value: "accept-all",
-                                    },
-                                    { name: "Reject this save", value: "reject" },
-                                ],
-                                default: "accept",
-                            });
+                        catch {
+                            overwriteMessage = style.green("(Will create new file)");
                         }
+                        let userResponse;
+                        if (toolExecutor) {
+                            const ctx = {
+                                toolName: SaveFileTool.name,
+                                toolCallId,
+                                message: `What would you like to do with this save? ${overwriteMessage}`,
+                                choices: {
+                                    accept: "Accept this save",
+                                    acceptAll: "Accept all future saves (including this)",
+                                    reject: "Reject this save",
+                                },
+                            };
+                            try {
+                                userResponse = await toolExecutor.ask(ctx, { abortSignal });
+                            }
+                            catch (e) {
+                                if (e.name === "AbortError") {
+                                    throw new Error("File saving aborted during user input");
+                                }
+                                throw e;
+                            }
+                        }
+                        const { result: userChoice, reason } = userResponse ?? {
+                            result: "accept",
+                        };
                         terminal.lineBreak();
                         if (userChoice === "accept-all") {
-                            autoAcceptSaves = true;
-                            terminal.writeln(chalk.yellow("✓ Auto-accept mode enabled for all future saves"));
+                            terminal.writeln(style.yellow("✓ Auto-accept mode enabled for all saves"));
                             terminal.lineBreak();
                         }
                         if (userChoice === "reject") {
-                            const reason = await input({ message: "Feedback: " });
                             terminal.lineBreak();
+                            const rejectionReason = reason || "No reason provided";
                             sendData?.({
                                 id: toolCallId,
                                 event: "tool-completion",
-                                data: `Save rejected by user. Reason: ${reason}`,
+                                data: `Save rejected by user. Reason: ${rejectionReason}`,
                             });
-                            return `The user rejected this save. Reason: ${reason}`;
+                            return `The user rejected this save. Reason: ${rejectionReason}`;
                         }
                         // If accepted, proceed to write file
                     }
-                    // Ensure parent directory exists
-                    await fs.mkdir(path.dirname(filePath), { recursive: true });
-                    await fs.writeFile(filePath, content, { encoding });
+                    // Pre-side-effect check
+                    if (abortSignal?.aborted) {
+                        throw new Error("File saving aborted before writing");
+                    }
+                    // Ensure parent directory exists (create missing parents)
+                    const parentDir = path.dirname(filePath);
+                    await fs.mkdir(parentDir, { recursive: true });
+                    await fs.writeFile(filePath, content, {
+                        encoding,
+                        signal: abortSignal,
+                    });
                     sendData?.({
                         id: toolCallId,
                         event: "tool-completion",

package/dist/tools/think.d.ts

@@ -9,3 +9,4 @@ export declare const createThinkTool: (options?: {
         thought: string;
     }, string>;
 };
+//# sourceMappingURL=think.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../source/tools/think.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,SAAS;;CAErB,CAAC;AAYF,eAAO,MAAM,eAAe,GAC1B,UAAS;IAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;CAAO;;;;CAmClD,CAAC"}

package/dist/tools/think.js

@@ -20,7 +20,11 @@ export const createThinkTool = (options = {}) => {
             inputSchema: z.object({
                 thought: z.string().describe("Your thought"),
             }),
-            execute: ({ thought }, { toolCallId }) => {
+            execute: ({ thought }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("Thinking process aborted");
+                }
                 // Replace literal '\\n' with actual newline characters
                 const formattedThought = thought.replace(/\\n/g, "\n");
                 sendData?.({

package/dist/tools/types.d.ts

@@ -1,5 +1,17 @@
 import { z } from "zod";
-export declare const fileEncodingSchema: z.ZodEnum<["ascii", "utf8", "utf-8", "utf16le", "ucs2", "ucs-2", "base64", "base64url", "latin1", "binary", "hex"]>;
+export declare const fileEncodingSchema: z.ZodEnum<{
+    utf8: "utf8";
+    ascii: "ascii";
+    "utf-8": "utf-8";
+    utf16le: "utf16le";
+    ucs2: "ucs2";
+    "ucs-2": "ucs-2";
+    base64: "base64";
+    base64url: "base64url";
+    latin1: "latin1";
+    binary: "binary";
+    hex: "hex";
+}>;
 interface MessageData {
     primary: string;
     secondary?: string[] | undefined;
@@ -27,3 +39,4 @@ interface ToolUpdateMessage extends BaseMessage {
 export type Message = ToolInitMessage | ToolErrorMessage | ToolCompletionMessage | ToolUpdateMessage;
 export type SendData = ({ data, event, id, retry, }: Message) => void | Promise<void>;
 export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CAClC;AAED,UAAU,WAAW;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,eAAgB,SAAQ,WAAW;IAC3C,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,gBAAiB,SAAQ,WAAW;IAC5C,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,qBAAsB,SAAQ,WAAW;IACjD,KAAK,EAAE,iBAAiB,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,iBAAkB,SAAQ,WAAW;IAC7C,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,MAAM,MAAM,OAAO,GACf,eAAe,GACf,gBAAgB,GAChB,qBAAqB,GACrB,iBAAiB,CAAC;AAEtB,MAAM,MAAM,QAAQ,GAAG,CAAC,EACtB,IAAI,EACJ,KAAK,EACL,EAAE,EACF,KAAK,GACN,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/tools/web-fetch.d.ts

@@ -1,4 +1,4 @@
-import type { TokenCounter } from "../token-utils.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
 import type { SendData } from "./types.ts";
 export declare const WebFetchTool: {
     name: "webFetch";
@@ -11,7 +11,7 @@ export declare const createWebFetchTool: (options: {
         url: string;
     }, string>;
 };
-export type ContentType = "text/plain" | "text/html" | "text/markdown" | "application/json" | "application/xml" | "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/svg+xml" | "audio/mpeg" | "audio/wav" | "video/mp4" | "video/webm" | "application/zip" | "application/octet-stream";
+type ContentType = "text/plain" | "text/html" | "text/markdown" | "application/json" | "application/xml" | "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/svg+xml" | "audio/mpeg" | "audio/wav" | "video/mp4" | "video/webm" | "application/zip" | "application/octet-stream";
 export type ReadUrlResult = {
     contentType: ContentType;
     data: string;
@@ -45,3 +45,5 @@ export declare class HtmlCleaner {
      */
     private removeEmptyElements;
 }
+export {};
+//# sourceMappingURL=web-fetch.d.ts.map

package/dist/tools/web-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../source/tools/web-fetch.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,SAAS;IAC1C,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;CAyCA,CAAC;AAEF,KAAK,WAAW,GACZ,YAAY,GACZ,WAAW,GACX,eAAe,GACf,kBAAkB,GAClB,iBAAiB,GACjB,iBAAiB,GACjB,WAAW,GACX,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,eAAe,GACf,YAAY,GACZ,WAAW,GACX,WAAW,GACX,YAAY,GACZ,iBAAiB,GACjB,0BAA0B,CAAC;AAE/B,MAAM,MAAM,aAAa,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GACpC,OAAO,CAAC,aAAa,CAAC,CA6HxB;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW;IAIrC,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO;IAIP;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM;IAuBhE;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAyCjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuBzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAG5B"}

package/dist/tools/web-fetch.js

@@ -1,8 +1,8 @@
 import { tool } from "ai";
-import chalk from "chalk";
 import { load } from "cheerio";
 import { z } from "zod";
 import { logger } from "../logger.js";
+import style from "../terminal/style.js";
 export const WebFetchTool = {
     name: "webFetch",
 };
@@ -19,7 +19,7 @@ export const createWebFetchTool = (options) => {
                     sendData?.({
                         event: "tool-init",
                         id: toolCallId,
-                        data: `Reading URL: ${chalk.cyan(url)}`,
+                        data: `Reading URL: ${style.cyan(url)}`,
                     });
                     logger.info(`Initiating fetch for URL: ${url}`);
                     const result = await readUrl(url, abortSignal);

package/dist/tools/web-search.d.ts

@@ -1,4 +1,4 @@
-import type { TokenCounter } from "../token-utils.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
 import type { SendData } from "./types.ts";
 export declare const WebSearchTool: {
     name: "webSearch";
@@ -11,3 +11,4 @@ export declare const createWebSearchTool: ({ sendData, tokenCounter, }: {
         query: string;
     }, string>;
 };
+//# sourceMappingURL=web-search.d.ts.map

package/dist/tools/web-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-search.d.ts","sourceRoot":"","sources":["../../source/tools/web-search.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,aAAa;;CAEzB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,6BAGjC;IACD,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;CA0CA,CAAC"}

package/dist/tools/web-search.js

@@ -1,8 +1,8 @@
 import { tool } from "ai";
-import chalk from "chalk";
 import { SafeSearchType, search } from "duck-duck-scrape";
-import Exa from "exa-js";
 import { z } from "zod";
+import Exa from "../api/exa/index.js";
+import style from "../terminal/style.js";
 export const WebSearchTool = {
     name: "webSearch",
 };
@@ -13,13 +13,20 @@ export const createWebSearchTool = ({ sendData, tokenCounter, }) => {
             inputSchema: z.object({
                 query: z.string().describe("The search query."),
             }),
-            execute: async ({ query }, { toolCallId }) => {
+            execute: async ({ query }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("Web search aborted");
+                }
                 sendData?.({
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Web search: ${chalk.cyan(query)}`,
+                    data: `Web search: ${style.cyan(query)}`,
                 });
-                const result = await performSearch(query);
+                if (abortSignal?.aborted) {
+                    throw new Error("Web search aborted before search execution");
+                }
+                const result = await performSearch(query, abortSignal);
                 const sources = result.results.map((source) => `## ${source.title}\nURL: ${source.url}\n\n${source.text}`);
                 const resultText = `# Search Results:\n\n${sources.join("\n\n")}`;
                 const tokenCount = tokenCounter.count(resultText);
@@ -33,36 +40,64 @@ export const createWebSearchTool = ({ sendData, tokenCounter, }) => {
         }),
     };
 };
-async function performSearch(query) {
+async function performSearch(query, abortSignal) {
     // Check if EXA API key is available
     const hasExaApiKey = process.env["EXA_API_KEY"] && process.env["EXA_API_KEY"].trim() !== "";
     if (hasExaApiKey) {
         // Use Exa search
         try {
+            if (abortSignal?.aborted) {
+                throw new Error("Web search aborted before Exa search");
+            }
             const exa = new Exa(process.env["EXA_API_KEY"]);
-            const result = await exa.searchAndContents(query, {
+            // Create a promise that races with the abort signal
+            const searchPromise = exa.searchAndContents(query, {
                 numResults: 5,
                 text: true,
             });
+            const result = await Promise.race([
+                searchPromise,
+                new Promise((_, reject) => {
+                    if (abortSignal) {
+                        abortSignal.addEventListener("abort", () => {
+                            reject(new Error("Web search aborted during Exa search"));
+                        });
+                    }
+                }),
+            ]);
             return result;
         }
         catch (error) {
             // If Exa fails, fall back to duck duck scrape
             console.info("Exa search failed, falling back to DuckDuckGo:", error);
-            return await searchWithDuckDuckGo(query);
+            return await searchWithDuckDuckGo(query, abortSignal);
         }
     }
     else {
         // Use DuckDuckGo search as fallback
         console.info("EXA_API_KEY not set, using DuckDuckGo search");
-        return await searchWithDuckDuckGo(query);
+        return await searchWithDuckDuckGo(query, abortSignal);
     }
 }
-async function searchWithDuckDuckGo(query) {
+async function searchWithDuckDuckGo(query, abortSignal) {
     try {
-        const searchResults = await search(query, {
+        if (abortSignal?.aborted) {
+            throw new Error("Web search aborted before DuckDuckGo search");
+        }
+        // Create a promise that races with the abort signal
+        const searchPromise = search(query, {
             safeSearch: SafeSearchType.MODERATE,
         });
+        const searchResults = await Promise.race([
+            searchPromise,
+            new Promise((_, reject) => {
+                if (abortSignal) {
+                    abortSignal.addEventListener("abort", () => {
+                        reject(new Error("Web search aborted during DuckDuckGo search"));
+                    });
+                }
+            }),
+        ]);
         // Transform duck-duck-scrape results to match Exa format
         // Take only first 5 results to match Exa behavior
         const results = searchResults.results

package/dist/utils/filesystem.d.ts

@@ -0,0 +1,23 @@
+export declare function toPath(urlOrPath: URL | string): string;
+/**
+ * Converts Windows backslashes to POSIX forward slashes.
+ * Preserves UNC paths and extended-length paths.
+ * @param inputPath - Path to convert
+ * @returns Path with forward slashes
+ */
+export declare function slash(inputPath: string): string;
+/**
+ * Checks if a path exists and is a directory.
+ * @param filePath - Path to check (URL or string)
+ * @returns Promise resolving to true if path is a directory
+ * @throws TypeError if input is invalid
+ */
+export declare function isDirectory(filePath: URL | string): Promise<boolean>;
+/**
+ * Safely clears all contents of a directory.
+ * @param directoryPath - Path to the directory to clear (URL or string)
+ * @returns Promise that resolves when directory is cleared
+ * @throws Error if directory cannot be cleared or if path is invalid/unsafe
+ */
+export declare function clearDirectory(directoryPath: URL | string): Promise<void>;
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/utils/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../source/utils/filesystem.ts"],"names":[],"mappings":"AAIA,wBAAgB,MAAM,CAAC,SAAS,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAS/C;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAmB1E;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,aAAa,EAAE,GAAG,GAAG,MAAM,GAC1B,OAAO,CAAC,IAAI,CAAC,CAuGf"}

package/dist/utils/filesystem.js

@@ -0,0 +1,140 @@
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+export function toPath(urlOrPath) {
+    return urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+}
+/**
+ * Converts Windows backslashes to POSIX forward slashes.
+ * Preserves UNC paths and extended-length paths.
+ * @param inputPath - Path to convert
+ * @returns Path with forward slashes
+ */
+export function slash(inputPath) {
+    const isExtendedLengthPath = inputPath.startsWith("\\\\?\\");
+    const isUncPath = inputPath.startsWith("\\\\");
+    if (isExtendedLengthPath || isUncPath) {
+        return inputPath;
+    }
+    return inputPath.replace(/\\/g, "/");
+}
+/**
+ * Checks if a path exists and is a directory.
+ * @param filePath - Path to check (URL or string)
+ * @returns Promise resolving to true if path is a directory
+ * @throws TypeError if input is invalid
+ */
+export async function isDirectory(filePath) {
+    const resolvedPath = path.resolve(toPath(filePath));
+    if (typeof resolvedPath !== "string" || !resolvedPath.trim()) {
+        throw new TypeError(`Expected a non-empty string or URL, got ${typeof filePath}`);
+    }
+    try {
+        const stats = await fsPromises.stat(resolvedPath);
+        return stats.isDirectory();
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+/**
+ * Safely clears all contents of a directory.
+ * @param directoryPath - Path to the directory to clear (URL or string)
+ * @returns Promise that resolves when directory is cleared
+ * @throws Error if directory cannot be cleared or if path is invalid/unsafe
+ */
+export async function clearDirectory(directoryPath) {
+    // Convert URL to path and resolve to absolute path
+    const resolvedPath = path.resolve(toPath(directoryPath));
+    // Input validation
+    if (typeof resolvedPath !== "string" || !resolvedPath.trim()) {
+        throw new TypeError("Directory path must be a non-empty string");
+    }
+    // Safety checks - prevent clearing root or dangerous paths
+    const parsedPath = path.parse(resolvedPath);
+    const isRoot = resolvedPath === parsedPath.root;
+    const isCurrentDir = resolvedPath === "." || resolvedPath === path.resolve(".");
+    if (isRoot || isCurrentDir) {
+        throw new Error(`Refusing to clear dangerous path: ${resolvedPath}`);
+    }
+    try {
+        // Check if directory exists and is accessible
+        try {
+            const lst = await fsPromises.lstat(resolvedPath);
+            if (lst.isSymbolicLink()) {
+                throw new Error(`Refusing to clear symlink directory: ${resolvedPath}`);
+            }
+            if (!lst.isDirectory()) {
+                throw new Error(`Path is not a directory: ${resolvedPath}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                // Directory doesn't exist, nothing to clear
+                return;
+            }
+            throw error;
+        }
+        // Read directory contents
+        const entries = await fsPromises.readdir(resolvedPath, {
+            withFileTypes: true,
+        });
+        // Delete all entries with concurrency control and proper error handling
+        const maxConcurrent = 50; // Limit concurrent operations to avoid EMFILE
+        const errors = [];
+        // Process entries in batches to control concurrency
+        for (let i = 0; i < entries.length; i += maxConcurrent) {
+            const batch = entries.slice(i, i + maxConcurrent);
+            const deletionPromises = batch.map(async (entry) => {
+                const entryPath = path.join(resolvedPath, entry.name);
+                const relativePath = path.relative(process.cwd(), entryPath);
+                try {
+                    if (entry.isSymbolicLink()) {
+                        // Always unlink symlinks, don't recurse
+                        await fsPromises.unlink(entryPath);
+                    }
+                    else if (entry.isDirectory()) {
+                        // Recursively delete subdirectories
+                        await clearDirectory(entryPath);
+                        // Use rm instead of deprecated rmdir
+                        await fsPromises.rm(entryPath, { recursive: true });
+                    }
+                    else {
+                        // Delete files using rm for consistency
+                        await fsPromises.rm(entryPath, { force: false });
+                    }
+                }
+                catch (error) {
+                    const err = error;
+                    errors.push({
+                        path: relativePath,
+                        error: err,
+                        op: entry.isDirectory() ? "rm" : "unlink",
+                    });
+                }
+            });
+            await Promise.all(deletionPromises);
+        }
+        // If any deletions failed, throw aggregated error
+        if (errors.length > 0) {
+            const errorDetails = errors
+                .map(({ path, error, op }) => {
+                const errnoError = error;
+                return `${path} (${op}): ${error.message} (${errnoError.code || "UNKNOWN"})`;
+            })
+                .join("; ");
+            throw new Error(`Failed to delete ${errors.length} entries: ${errorDetails}`, {
+                cause: errors[0].error,
+            });
+        }
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to clear directory ${resolvedPath}: ${err.message}`, { cause: err });
+    }
+}

package/dist/utils/filetype-detection.d.ts

@@ -0,0 +1,3 @@
+export declare function getLanguageFromFilePath(filePath: string): string | undefined;
+export declare function getCodeblockFromFilePath(filePath: string): string | undefined;
+//# sourceMappingURL=filetype-detection.d.ts.map

package/dist/utils/filetype-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filetype-detection.d.ts","sourceRoot":"","sources":["../../source/utils/filetype-detection.ts"],"names":[],"mappings":"AA+FA,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAW5E;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAW7E"}