@travisennis/acai 0.0.12 → 0.0.14

package/dist/utils/command-protection.js

@@ -2,6 +2,7 @@
  * Command Protection Module
  * Detects and blocks destructive commands that could cause data loss
  */
+import path from "node:path";
 /**
  * Check if a git subcommand appears as an actual command (not inside quoted strings).
  * This helps avoid false positives when destructive command text appears in
@@ -91,6 +92,34 @@ export function detectDestructiveCommand(command) {
     }
     return { blocked: false };
 }
+/**
+ * Check if a git restore command will discard uncommitted changes
+ * (restore without --staged and not creating a branch with -b)
+ */
+function isDestructiveGitRestore(lowerCommand) {
+    if (!lowerCommand.startsWith("git restore"))
+        return false;
+    if (lowerCommand.includes(" --staged"))
+        return false;
+    const afterRestore = lowerCommand.substring("git restore".length).trim();
+    return !!afterRestore && !afterRestore.startsWith("-b");
+}
+/**
+ * Check if a git branch command uses -D (force delete without merge check)
+ */
+function isDestructiveGitBranchD(command, lowerCommand) {
+    const branchMatch = lowerCommand.match(/git\s+branch\s+-([a-z])/);
+    if (!branchMatch)
+        return false;
+    // Check if the flag in the original command is uppercase
+    const flagInOriginal = command.match(/git\s+branch\s+-([A-Za-z])/i);
+    if (!flagInOriginal)
+        return false;
+    if (flagInOriginal[1] !== flagInOriginal[1].toUpperCase())
+        return false;
+    // Verify this is an actual git branch command, not text inside quotes
+    return isActualGitCommand(command, "branch");
+}
 /**
  * Detect destructive git commands
  */
@@ -116,18 +145,13 @@ function detectDestructiveGitCommands(command) {
         };
     }
     // Block git restore without --staged (discards uncommitted changes)
-    if (lowerCommand.startsWith("git restore") &&
-        !lowerCommand.includes(" --staged")) {
-        // Check if it's restoring files (not branches)
-        const afterRestore = lowerCommand.substring("git restore".length).trim();
-        if (afterRestore && !afterRestore.startsWith("-b")) {
-            return {
-                blocked: true,
-                reason: "git restore <file> (without --staged) discards uncommitted changes",
-                command,
-                tip: "Use 'git restore --staged <file>' to only unstage, or 'git stash' to save changes.",
-            };
-        }
+    if (isDestructiveGitRestore(lowerCommand)) {
+        return {
+            blocked: true,
+            reason: "git restore <file> (without --staged) discards uncommitted changes",
+            command,
+            tip: "Use 'git restore --staged <file>' to only unstage, or 'git stash' to save changes.",
+        };
     }
     // Block git clean -f (force deletes untracked files)
     if (lowerCommand.includes("git clean -f") ||
@@ -151,27 +175,13 @@ function detectDestructiveGitCommands(command) {
         };
     }
     // Block git branch -D (force delete without merge check)
-    // Check for uppercase flag on original command (lowercase -d is safe)
-    // Match 'git' case-insensitively, but preserve case for the flag
-    // Only match if git branch appears as an actual command (not inside quoted strings)
-    const branchMatch = lowerCommand.match(/git\s+branch\s+-([a-z])/);
-    if (branchMatch) {
-        // Check if the flag in the original command is uppercase
-        const flagInOriginal = command.match(/git\s+branch\s+-([A-Za-z])/i);
-        if (flagInOriginal &&
-            flagInOriginal[1] === flagInOriginal[1].toUpperCase()) {
-            // Verify this is an actual git branch command, not text inside quotes
-            // Check if git branch appears at start or after command separators
-            const isActualCommand = isActualGitCommand(command, "branch");
-            if (isActualCommand) {
-                return {
-                    blocked: true,
-                    reason: "git branch -D force-deletes branches without checking if they're merged",
-                    command,
-                    tip: "Use 'git branch -d' (lowercase) to safely delete branches that are merged.",
-                };
-            }
-        }
+    if (isDestructiveGitBranchD(command, lowerCommand)) {
+        return {
+            blocked: true,
+            reason: "git branch -D force-deletes branches without checking if they're merged",
+            command,
+            tip: "Use 'git branch -d' (lowercase) to safely delete branches that are merged.",
+        };
     }
     // Block git stash drop and git stash clear
     if (lowerCommand.includes("git stash drop") ||
@@ -189,49 +199,168 @@ function detectDestructiveGitCommands(command) {
  * Detect dangerous rm -rf commands outside of temporary directories
  */
 function detectDangerousRmRf(command) {
-    // Check for rm -rf pattern (case insensitive)
-    const rmMatch = command.match(/rm\s+-rf\s+/i);
-    if (!rmMatch || rmMatch.index === undefined) {
-        return { blocked: false };
+    const tokens = tokenizeShellCommand(command);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (!token || token.separator || token.value !== "rm")
+            continue;
+        const rmArgs = collectCommandArguments(tokens, i + 1);
+        if (!isRecursiveForceRm(rmArgs))
+            continue;
+        const paths = getRmPathArguments(rmArgs);
+        if (paths.length === 0)
+            continue;
+        if (paths.every(isTempDirectoryOnly))
+            continue;
+        return {
+            blocked: true,
+            reason: "rm -rf outside of temporary directories can cause permanent data loss",
+            command,
+            tip: "Only rm -rf is allowed for /tmp/*, /var/tmp/*, or $TMPDIR/* to clean temporary files.",
+        };
     }
-    // Extract the path argument
-    const matchIndex = rmMatch.index + rmMatch[0].length;
-    const afterRmRf = command.substring(matchIndex).trim();
-    // If no path specified, don't block (will fail naturally)
-    if (!afterRmRf) {
-        return { blocked: false };
+    return { blocked: false };
+}
+function tokenizeShellCommand(command) {
+    const state = {
+        tokens: [],
+        current: "",
+        inSingleQuote: false,
+        inDoubleQuote: false,
+        escaped: false,
+    };
+    for (let i = 0; i < command.length; i++) {
+        consumeShellChar(state, command[i] ?? "");
+    }
+    pushShellToken(state);
+    return state.tokens;
+}
+function consumeShellChar(state, char) {
+    if (state.escaped) {
+        state.current += char;
+        state.escaped = false;
+        return;
+    }
+    if (char === "\\" && !state.inSingleQuote) {
+        state.escaped = true;
+        return;
+    }
+    if (char === "'" && !state.inDoubleQuote) {
+        state.inSingleQuote = !state.inSingleQuote;
+        return;
+    }
+    if (char === '"' && !state.inSingleQuote) {
+        state.inDoubleQuote = !state.inDoubleQuote;
+        return;
     }
-    // Get temporary directory paths
-    const tempDirs = ["/tmp", "/var/tmp", process.env["TMPDIR"] || "/tmp"];
-    // Check if the path is explicitly targeting only temp directories
-    // This handles: rm -rf /tmp/*, rm -rf /var/tmp/*, rm -rf $TMPDIR/*, and any subpaths
-    const isTempDirectoryOnly = tempDirs.some((tempDir) => {
-        // Check if path starts with temp directory (e.g., /tmp/foo, /tmp/*)
-        if (afterRmRf === tempDir || afterRmRf.startsWith(`${tempDir}/`)) {
-            return true;
+    if (isTokenBoundary(state, char)) {
+        pushShellToken(state);
+        if (char === "\n" || isShellSeparator(char)) {
+            state.tokens.push({ value: char, separator: true });
         }
-        return false;
-    });
-    // Also check for $TMPDIR/* pattern (literal strings)
-    // Using string concatenation to avoid lint warnings about template-like strings
+        return;
+    }
+    state.current += char;
+}
+function isTokenBoundary(state, char) {
+    return (!state.inSingleQuote &&
+        !state.inDoubleQuote &&
+        (/\s/.test(char) || isShellSeparator(char)));
+}
+function pushShellToken(state) {
+    if (!state.current)
+        return;
+    state.tokens.push({ value: state.current, separator: false });
+    state.current = "";
+}
+function isShellSeparator(char) {
+    return char === ";" || char === "|" || char === "&";
+}
+function collectCommandArguments(tokens, startIndex) {
+    const args = [];
+    for (let i = startIndex; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (!token || token.separator)
+            break;
+        args.push(token.value);
+    }
+    return args;
+}
+function isRecursiveForceRm(args) {
+    const flags = { recursive: false, force: false };
+    for (const arg of args) {
+        if (arg === "--")
+            break;
+        updateRmFlagState(flags, arg);
+    }
+    return flags.recursive && flags.force;
+}
+function updateRmFlagState(flags, arg) {
+    if (arg === "--recursive") {
+        flags.recursive = true;
+        return;
+    }
+    if (arg === "--force") {
+        flags.force = true;
+        return;
+    }
+    if (!/^-[^-]+$/.test(arg))
+        return;
+    if (arg.includes("r") || arg.includes("R"))
+        flags.recursive = true;
+    if (arg.includes("f"))
+        flags.force = true;
+}
+function getRmPathArguments(args) {
+    const paths = [];
+    let parsingOptions = true;
+    for (const arg of args) {
+        if (parsingOptions && arg === "--") {
+            parsingOptions = false;
+            continue;
+        }
+        if (parsingOptions && isRmOption(arg))
+            continue;
+        paths.push(arg);
+    }
+    return paths;
+}
+function isRmOption(arg) {
+    return arg.startsWith("-") && arg !== "-";
+}
+function isTempDirectoryOnly(inputPath) {
     const tmpDirVar = "$" + "TMPDIR";
     const tmpDirVarBraces = "$" + "{TMPDIR}";
-    if (afterRmRf === tmpDirVar ||
-        afterRmRf.startsWith(`${tmpDirVar}/`) ||
-        afterRmRf === tmpDirVarBraces ||
-        afterRmRf.startsWith(`${tmpDirVarBraces}/`)) {
-        return { blocked: false };
+    if (isTempVariablePath(inputPath, tmpDirVar) ||
+        isTempVariablePath(inputPath, tmpDirVarBraces)) {
+        return true;
     }
-    if (isTempDirectoryOnly) {
-        return { blocked: false };
+    if (!inputPath.startsWith("/"))
+        return false;
+    const normalizedPath = normalizeAbsolutePath(inputPath);
+    const tempDirs = ["/tmp", "/var/tmp", process.env["TMPDIR"] || "/tmp"].map(normalizeAbsolutePath);
+    return tempDirs.some((tempDir) => normalizedPath === tempDir || normalizedPath.startsWith(`${tempDir}/`));
+}
+function isTempVariablePath(inputPath, variable) {
+    if (inputPath !== variable && !inputPath.startsWith(`${variable}/`)) {
+        return false;
     }
-    // Block any other rm -rf
-    return {
-        blocked: true,
-        reason: "rm -rf outside of temporary directories can cause permanent data loss",
-        command,
-        tip: "Only rm -rf is allowed for /tmp/*, /var/tmp/*, or $TMPDIR/* to clean temporary files.",
-    };
+    const suffix = inputPath.slice(variable.length);
+    return !suffix.split("/").includes("..");
+}
+function normalizeAbsolutePath(inputPath) {
+    return path.posix.normalize(inputPath.replace(/\/+$/, "") || "/");
+}
+function detectDangerousRmRfInText(content) {
+    const rmCommandPattern = /\brm\b[^\n;&|)]*/gi;
+    let match = rmCommandPattern.exec(content);
+    while (match !== null) {
+        const rmResult = detectDangerousRmRf(match[0]);
+        if (rmResult.blocked)
+            return rmResult;
+        match = rmCommandPattern.exec(content);
+    }
+    return { blocked: false };
 }
 /**
  * Detect dangerous patterns in inline scripts (-c flags)
@@ -259,9 +388,6 @@ function detectDangerousInlineScripts(command) {
                 /git\s+push\s+(-f|--force)/i,
                 /git\s+branch\s+-[A-Z]/i,
                 /git\s+stash\s+(drop|clear)/i,
-                /rm\s+-rf\s+\/home/i,
-                /rm\s+-rf\s+\/usr/i,
-                /rm\s+-rf\s+~/i,
             ];
             // Check if any destructive pattern is present in the command
             for (const destructivePattern of destructivePatterns) {
@@ -274,6 +400,15 @@ function detectDangerousInlineScripts(command) {
                     };
                 }
             }
+            const rmResult = detectDangerousRmRfInText(command);
+            if (rmResult.blocked) {
+                return {
+                    blocked: true,
+                    reason: `Inline ${language} script contains destructive operation`,
+                    command,
+                    tip: "Review the script content for destructive commands.",
+                };
+            }
         }
     }
     return { blocked: false };
@@ -362,34 +497,12 @@ function detectDangerousScriptContent(content) {
             };
         }
     }
-    // Check for dangerous rm -rf patterns (more permissive for scripts, block obvious dangers)
-    const dangerousRmPatterns = [
-        /\brm\s+-rf\s+\/[^\s*]*[a-z]/i, // rm -rf /something (but allow /tmp/* patterns)
-        /\brm\s+-rf\s+\/home/i,
-        /\brm\s+-rf\s+\/usr/i,
-        /\brm\s+-rf\s+\/etc/i,
-        /\brm\s+-rf\s+\/var\s*$/i, // Block /var alone but allow /var/tmp
-        /\brm\s+-rf\s+~(?!\/)/i, // rm -rf ~ but allow ~/tmp
-    ];
-    for (const pattern of dangerousRmPatterns) {
-        if (pattern.test(content)) {
-            return {
-                blocked: true,
-                tip: "The script contains a dangerous rm -rf command.",
-            };
-        }
-    }
-    // Check for format string attacks and other dangerous patterns
-    const dangerousPatterns = [
-        /\brm\s+-rf\s+\$\w+/i, // rm -rf $VAR (variable expansion could be dangerous)
-    ];
-    for (const pattern of dangerousPatterns) {
-        if (pattern.test(content)) {
-            return {
-                blocked: true,
-                tip: "The script contains a potentially dangerous rm command with variable expansion.",
-            };
-        }
+    const rmResult = detectDangerousRmRfInText(content);
+    if (rmResult.blocked) {
+        return {
+            blocked: true,
+            tip: "The script contains a dangerous rm -rf command.",
+        };
     }
     return { blocked: false };
 }

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

@@ -1,18 +1,3 @@
-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)

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

@@ -1 +1 @@
-{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/operations.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"}
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/operations.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,aAAa,EAAE,GAAG,GAAG,MAAM,GAC1B,OAAO,CAAC,IAAI,CAAC,CAuGf"}

package/dist/utils/filesystem/operations.js

@@ -1,46 +1,9 @@
 import * as fsPromises from "node:fs/promises";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-export function toPath(urlOrPath) {
+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)

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

@@ -1 +1 @@
-{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/security.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAsCpD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK3E;AAoCD,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAIT;AAsCD,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,EACnC,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CAAO,GACtE,OAAO,CAAC,MAAM,CAAC,CAmGjB;AA8BD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,GACjB,IAAI,CAIN"}
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../source/utils/filesystem/security.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAsCpD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK3E;AAoCD,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAKT;AA2DD,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,EACnC,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CAAO,GACtE,OAAO,CAAC,MAAM,CAAC,CAuFjB;AA8BD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,GACjB,IAAI,CAIN"}

package/dist/utils/filesystem/security.js

@@ -75,7 +75,10 @@ function isPathWithinBaseDir(requestedPath, baseDir) {
 }
 // Check if path is within any of the allowed directories
 export function isPathWithinAllowedDirs(requestedPath, allowedDirs) {
-    return allowedDirs.some((allowedDir) => isPathWithinBaseDir(requestedPath, allowedDir));
+    return allowedDirs.some((allowedDir) => {
+        const expandedDir = expandHome(allowedDir);
+        return isPathWithinBaseDir(requestedPath, expandedDir);
+    });
 }
 async function resolveValidAncestor(startDir, isWithinAllowed) {
     let current = startDir;
@@ -104,6 +107,21 @@ async function resolveValidAncestor(startDir, isWithinAllowed) {
         }
     }
 }
+async function ensurePathExists(validatedPath, requestedPath, abortSignal) {
+    if (abortSignal?.aborted) {
+        throw new Error("Path validation aborted during existence check");
+    }
+    try {
+        await fs.stat(validatedPath);
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "ENOENT") {
+            throw new Error(`The specified path does not exist: ${requestedPath} (${validatedPath})`);
+        }
+        throw error;
+    }
+}
 // Security utilities
 export async function validatePath(requestedPath, allowedDirectory, options = {}) {
     const { requireExistence = true, abortSignal } = options;
@@ -121,7 +139,8 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
         : [allowedDirectory];
     // Resolve and normalize all allowed directories
     const normalizedAllowedDirs = await Promise.all(allowedDirectories.map(async (dir) => {
-        let normalizedDir = normalizePath(path.resolve(dir));
+        const expandedDir = expandHome(dir);
+        let normalizedDir = normalizePath(path.resolve(expandedDir));
         // Try to resolve real path for allowedDirectory when it exists to handle symlinked roots
         try {
             const stats = await fs.stat(normalizedDir);
@@ -171,19 +190,7 @@ export async function validatePath(requestedPath, allowedDirectory, options = {}
     }
     // Now, if requireExistence, check if the path exists
     if (requireExistence) {
-        if (abortSignal?.aborted) {
-            throw new Error("Path validation aborted during existence check");
-        }
-        try {
-            await fs.stat(validatedPath);
-        }
-        catch (err) {
-            const error = err;
-            if (error.code === "ENOENT") {
-                throw new Error(`The specified path does not exist: ${requestedPath} (${validatedPath})`);
-            }
-            throw error;
-        }
+        await ensurePathExists(validatedPath, requestedPath, abortSignal);
     }
     return validatedPath;
 }

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

@@ -1,3 +1,2 @@
-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

@@ -1 +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"}
+{"version":3,"file":"filetype-detection.d.ts","sourceRoot":"","sources":["../../source/utils/filetype-detection.ts"],"names":[],"mappings":"AA+FA,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAW7E"}

package/dist/utils/filetype-detection.js

@@ -86,18 +86,6 @@ const extensionToLanguageMap = {
     ".proto": { name: "Protocol Buffers", codeblock: "protobuf" },
     ".txt": { name: "Text", codeblock: "text" },
 };
-export function getLanguageFromFilePath(filePath) {
-    const extension = extname(filePath).toLowerCase();
-    const languageInfo = extension
-        ? extensionToLanguageMap[extension]
-        : undefined;
-    if (languageInfo) {
-        return languageInfo.name;
-    }
-    const filename = basename(filePath).toLowerCase();
-    const filenameLanguageInfo = extensionToLanguageMap[`.${filename}`];
-    return filenameLanguageInfo?.name;
-}
 export function getCodeblockFromFilePath(filePath) {
     const extension = extname(filePath).toLowerCase();
     const languageInfo = extension

package/dist/utils/formatting.d.ts

@@ -24,36 +24,6 @@ export type FormatType = "xml" | "markdown" | "bracket";
  * ```
  */
 export declare function formatFile(file: string, content: string, format: FormatType): string;
-/**
- * Formats URL content with metadata in the specified format.
- *
- * @param siteUrl - The URL to format
- * @param content - The URL content to format
- * @param format - The output format type
- * @returns Formatted URL content with metadata
- * @throws {Error} When an unsupported format is provided
- *
- * @example
- * ```typescript
- * formatUrl("https://example.com", "<html>...</html>", "xml")
- * // Returns: "<webpage>\n<url>https://example.com</url>\n<content>\n<html>...</html>\n</content>\n</webpage>"
- * ```
- */
-export declare function formatUrl(siteUrl: string, content: string, format: FormatType): string;
-/**
- * Formats content as a code block with appropriate language identifier.
- *
- * @param file - The file path used to determine the code block language
- * @param content - The code content to format
- * @returns Formatted code block with language identifier
- *
- * @example
- * ```typescript
- * formatCodeBlock("example.js", "console.log('hello');")
- * // Returns: "``` javascript\nconsole.log('hello');\n```"
- * ```
- */
-export declare function formatCodeBlock(file: string, content: string): string;
 /**
  * Formats generic content blocks with a name in the specified format.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../source/utils/formatting.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,SAAS,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAaR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAIrE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MACG,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,KAAG,MASjD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GAAI,cAAc,MAAM,KAAG,MAuCrD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAwC1C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,MASvC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAGvD,CAAC"}
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../source/utils/formatting.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,SAAS,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAaR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MACG,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,KAAG,MASjD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GAAI,cAAc,MAAM,KAAG,MAuCrD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAwC1C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,MASvC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAGvD,CAAC"}

package/dist/utils/formatting.js

@@ -35,50 +35,6 @@ export function formatFile(file, content, format) {
             throw new Error(`Unsupported format: ${format}`);
     }
 }
-/**
- * Formats URL content with metadata in the specified format.
- *
- * @param siteUrl - The URL to format
- * @param content - The URL content to format
- * @param format - The output format type
- * @returns Formatted URL content with metadata
- * @throws {Error} When an unsupported format is provided
- *
- * @example
- * ```typescript
- * formatUrl("https://example.com", "<html>...</html>", "xml")
- * // Returns: "<webpage>\n<url>https://example.com</url>\n<content>\n<html>...</html>\n</content>\n</webpage>"
- * ```
- */
-export function formatUrl(siteUrl, content, format) {
-    switch (format) {
-        case "xml":
-            return `<webpage>\n<url>${siteUrl}</url>\n<content>\n${content}\n</content>\n</webpage>`;
-        case "markdown":
-            return `## URL: ${siteUrl}\n${MD_TRIPLE_QUOTE}\n${content}\n${MD_TRIPLE_QUOTE}`;
-        case "bracket":
-            return `[url]: ${siteUrl}\n[url content begin]\n${content}\n[url content end]`;
-        default:
-            throw new Error(`Unsupported format: ${format}`);
-    }
-}
-/**
- * Formats content as a code block with appropriate language identifier.
- *
- * @param file - The file path used to determine the code block language
- * @param content - The code content to format
- * @returns Formatted code block with language identifier
- *
- * @example
- * ```typescript
- * formatCodeBlock("example.js", "console.log('hello');")
- * // Returns: "``` javascript\nconsole.log('hello');\n```"
- * ```
- */
-export function formatCodeBlock(file, content) {
-    const codeBlockName = getCodeblockFromFilePath(file) || path.extname(file).slice(1);
-    return `${MD_TRIPLE_QUOTE} ${codeBlockName}\n${content}\n${MD_TRIPLE_QUOTE}`;
-}
 /**
  * Formats generic content blocks with a name in the specified format.
  *