@travisennis/acai 0.0.3 → 0.0.5

package/dist/conversation-analyzer.d.ts

@@ -1,10 +1,11 @@
 import { type ModelMessage } from "ai";
 import type { ModelManager } from "./models/manager.ts";
 import type { Terminal } from "./terminal/index.ts";
-import type { TokenTracker } from "./token-tracker.ts";
+import type { TokenTracker } from "./tokens/tracker.ts";
 export declare function analyzeConversation({ modelManager, messages, tokenTracker, }: {
     modelManager: ModelManager;
     messages: ModelMessage[];
     terminal?: Terminal | undefined;
     tokenTracker: TokenTracker;
 }): Promise<string[]>;
+//# sourceMappingURL=conversation-analyzer.d.ts.map

package/dist/conversation-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-analyzer.d.ts","sourceRoot":"","sources":["../source/conversation-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,IAAI,CAAC;AAGrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAyCxD,wBAAsB,mBAAmB,CAAC,EACxC,YAAY,EACZ,QAAQ,EACR,YAAY,GACb,EAAE;IACD,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA0DpB"}

package/dist/dedent.d.ts

@@ -1,3 +1,4 @@
 type Dedent = (strings: TemplateStringsArray, ...values: unknown[]) => string;
 export declare const dedent: Dedent;
 export {};
+//# sourceMappingURL=dedent.d.ts.map

package/dist/dedent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedent.d.ts","sourceRoot":"","sources":["../source/dedent.ts"],"names":[],"mappings":"AAAA,KAAK,MAAM,GAAG,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC;AAI9E,eAAO,MAAM,MAAM,EAAE,MAgDpB,CAAC"}

package/dist/execution/index.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Result of a command execution
+ */
+interface ExecutionResult {
+    output: string;
+    exitCode: number;
+    error?: Error;
+    command: string;
+    duration: number;
+}
+/**
+ * Command execution options
+ */
+interface ExecutionOptions {
+    /** Working directory where the command will be executed */
+    cwd?: string;
+    env?: Record<string, string>;
+    /** Timeout in milliseconds before killing the process */
+    timeout?: number;
+    shell?: string;
+    /** Maximum buffer size in bytes (defaults to 1MB) */
+    maxBuffer?: number;
+    captureStderr?: boolean;
+    /** Whether to include stdout/stderr in the result even when there's an error (defaults to true) */
+    preserveOutputOnError?: boolean;
+    /** AbortSignal to cancel the execution */
+    abortSignal?: AbortSignal;
+    /** Whether to throw an error on non-zero exit codes (defaults to false) */
+    throwOnError?: boolean;
+}
+/**
+ * Background process options
+ */
+interface BackgroundProcessOptions extends ExecutionOptions {
+    onOutput?: (output: string) => void;
+    onError?: (error: string) => void;
+    onExit?: (code: number | null) => void;
+}
+/**
+ * Background process handle
+ */
+interface BackgroundProcess {
+    pid: number;
+    kill: () => boolean;
+    isRunning: boolean;
+}
+/**
+ * Execution environment manager
+ */
+interface ExecutionConfig {
+    env?: string;
+    execution?: {
+        cwd?: string;
+        env?: Record<string, string>;
+        shell?: string;
+        allowedCommands?: Array<string | RegExp>;
+    };
+}
+export declare class ExecutionEnvironment {
+    private config;
+    private backgroundProcesses;
+    private executionCount;
+    private workingDirectory;
+    private environmentVariables;
+    /**
+     * Create a new execution environment
+     */
+    constructor(config?: ExecutionConfig);
+    /**
+     * Initialize the execution environment
+     */
+    initialize(): Promise<void>;
+    /**
+     * Execute a shell command
+     */
+    executeCommand(command: string, options?: ExecutionOptions): Promise<ExecutionResult>;
+    /**
+     * Execute a command in the background
+     */
+    executeCommandInBackground(command: string, options?: BackgroundProcessOptions): BackgroundProcess;
+    /**
+     * Kill all running background processes
+     */
+    killAllBackgroundProcesses(): void;
+    /**
+     * Validate a command for safety
+     */
+    validateCommand(command: string): void;
+    /**
+     * Set the working directory
+     */
+    setWorkingDirectory(directory: string): void;
+    /**
+     * Get the working directory
+     */
+    getWorkingDirectory(): string;
+    /**
+     * Set an environment variable
+     */
+    setEnvironmentVariable(name: string, value: string): void;
+    /**
+     * Get an environment variable
+     */
+    getEnvironmentVariable(name: string): string | undefined;
+}
+/**
+ * Initialize the execution environment
+ */
+export declare function initExecutionEnvironment(config?: ExecutionConfig): Promise<ExecutionEnvironment>;
+export declare function setupProcessCleanup(executionEnv: ExecutionEnvironment): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/execution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/execution/index.ts"],"names":[],"mappings":"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"}

package/dist/execution/index.js

@@ -0,0 +1,432 @@
+/**
+ * Execution Environment Module
+ *
+ * Provides functionality for executing shell commands and scripts
+ * in a controlled environment with proper error handling.
+ */
+import { exec, spawn } from "node:child_process";
+import { logger } from "../logger.js";
+/**
+ * List of dangerous commands that shouldn't be executed
+ */
+const DANGEROUS_COMMANDS = [
+    /^\s*rm\s+(-rf?|--recursive)\s+[/~]/i, // rm -rf / or similar
+    /^\s*dd\s+.*of=\/dev\/(disk|hd|sd)/i, // dd to a device
+    /^\s*mkfs/i, // Format a filesystem
+    /^\s*:\(\)\{\s*:\|:\s*&\s*\}\s*;/, // Fork bomb
+    /^\s*>(\/dev\/sd|\/dev\/hd)/, // Overwrite disk device
+    /^\s*sudo\s+.*(rm|mkfs|dd|chmod|chown)/i, // sudo with dangerous commands
+];
+/**
+ * Maximum command execution time (30 seconds by default)
+ */
+const DEFAULT_TIMEOUT = 30000;
+/**
+ * Maximum output buffer size (5MB by default)
+ */
+const DEFAULT_MAX_BUFFER = 5 * 1024 * 1024;
+function getShell() {
+    return process.env["ZSH_VERSION"] ? "zsh" : process.env["SHELL"] || "bash";
+}
+function ttySizeEnv() {
+    const env = {};
+    if (process.stdout.isTTY &&
+        typeof process.stdout.columns === "number" &&
+        typeof process.stdout.rows === "number") {
+        env["COLUMNS"] = String(process.stdout.columns - 2);
+        env["LINES"] = String(process.stdout.rows);
+    }
+    else {
+        if (typeof process.env["COLUMNS"] === "string")
+            env["COLUMNS"] = process.env["COLUMNS"];
+        if (typeof process.env["LINES"] === "string")
+            env["LINES"] = process.env["LINES"];
+    }
+    return env;
+}
+export class ExecutionEnvironment {
+    config;
+    backgroundProcesses = new Map();
+    executionCount = 0;
+    workingDirectory;
+    environmentVariables;
+    /**
+     * Create a new execution environment
+     */
+    constructor(config = {}) {
+        this.config = config;
+        this.workingDirectory = config.execution?.cwd || process.cwd();
+        // Set up environment variables
+        this.environmentVariables = {
+            ...process.env,
+            // biome-ignore lint/style/useNamingConvention: environment variable.
+            NODE_ENV: config.env || "production",
+            ...(config.execution?.env || {}),
+        };
+        logger.debug({
+            workingDirectory: this.workingDirectory,
+        }, "Execution environment created");
+    }
+    /**
+     * Initialize the execution environment
+     */
+    async initialize() {
+        logger.info("Initializing execution environment");
+        try {
+            // Verify shell is available
+            const shell = this.config.execution?.shell || getShell();
+            await this.executeCommand(`${shell} -c "echo Shell is available"`, {
+                timeout: 5000,
+            });
+            logger.info("Execution environment initialized successfully");
+        }
+        catch (error) {
+            logger.error(error, "Failed to initialize execution environment");
+            throw new Error("Failed to initialize command execution environment", {
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Execute a shell command
+     */
+    async executeCommand(command, options = {}) {
+        // Increment execution count
+        this.executionCount++;
+        // Validate command for safety
+        this.validateCommand(command);
+        const cwd = options.cwd || this.workingDirectory;
+        const env = {
+            ...this.environmentVariables,
+            ...ttySizeEnv(),
+            ...(options.env || {}),
+        };
+        const timeout = options.timeout || DEFAULT_TIMEOUT;
+        const maxBuffer = options.maxBuffer || DEFAULT_MAX_BUFFER;
+        const shell = options.shell || this.config.execution?.shell || getShell();
+        const captureStderr = options.captureStderr !== false;
+        const preserveOutputOnError = options.preserveOutputOnError !== false;
+        const throwOnError = options.throwOnError === true;
+        logger.debug({
+            command,
+            cwd,
+            shell,
+            timeout,
+            executionCount: this.executionCount,
+            hasAbortSignal: !!options.abortSignal,
+        }, "Executing command");
+        const startTime = Date.now();
+        return new Promise((resolve, reject) => {
+            // Check if already aborted
+            if (options.abortSignal?.aborted) {
+                const error = new Error("Command execution aborted");
+                logger.warn({ command }, "Command execution aborted before starting");
+                resolve({
+                    output: "",
+                    exitCode: 1,
+                    error,
+                    command,
+                    duration: 0,
+                });
+                return;
+            }
+            const childProcess = exec(command, {
+                cwd,
+                env,
+                timeout,
+                maxBuffer,
+                shell,
+                windowsHide: true,
+                encoding: "utf8",
+            }, (error, stdout, stderr) => {
+                const duration = Date.now() - startTime;
+                // Combine stdout and stderr if requested
+                const output = captureStderr
+                    ? `${stdout}${stderr ? stderr : ""}`
+                    : stdout;
+                if (error) {
+                    logger.error({
+                        error: error.message,
+                        exitCode: error.code,
+                        duration,
+                    }, `Command execution failed: ${command}`);
+                    const result = {
+                        output: preserveOutputOnError ? output : "",
+                        exitCode: error.code || 1,
+                        error,
+                        command,
+                        duration,
+                    };
+                    if (throwOnError) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(result);
+                    }
+                }
+                else {
+                    logger.debug({
+                        duration,
+                        outputLength: output.length,
+                    }, `Command executed successfully: ${command}`);
+                    resolve({
+                        output,
+                        exitCode: 0,
+                        command,
+                        duration,
+                    });
+                }
+            });
+            // Handle abort signal
+            if (options.abortSignal) {
+                const abortHandler = () => {
+                    logger.warn({ command, pid: childProcess.pid }, "Command execution aborted");
+                    childProcess.kill("SIGTERM");
+                    const error = new Error("Command execution aborted");
+                    const result = {
+                        output: preserveOutputOnError ? "" : "",
+                        exitCode: 1,
+                        error,
+                        command,
+                        duration: Date.now() - startTime,
+                    };
+                    if (throwOnError) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(result);
+                    }
+                };
+                options.abortSignal.addEventListener("abort", abortHandler, {
+                    once: true,
+                });
+                // Clean up abort listener when process completes
+                childProcess.on("exit", () => {
+                    options.abortSignal?.removeEventListener("abort", abortHandler);
+                });
+            }
+        });
+    }
+    /**
+     * Execute a command in the background
+     */
+    executeCommandInBackground(command, options = {}) {
+        // Validate command for safety
+        this.validateCommand(command);
+        const cwd = options.cwd || this.workingDirectory;
+        const env = {
+            ...this.environmentVariables,
+            ...ttySizeEnv(),
+            ...(options.env || {}),
+        };
+        const shell = options.shell ||
+            this.config.execution?.shell ||
+            process.env["SHELL"] ||
+            "bash";
+        logger.debug({
+            command,
+            cwd,
+            shell,
+            hasAbortSignal: !!options.abortSignal,
+        }, "Executing command in background");
+        // Check if already aborted
+        if (options.abortSignal?.aborted) {
+            logger.warn({ command }, "Background command execution aborted before starting");
+            throw new Error("Background command execution aborted");
+        }
+        // Spawn the process
+        const childProcess = spawn(command, [], {
+            cwd,
+            env,
+            shell,
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const pid = childProcess.pid ?? -1;
+        let isRunning = true;
+        // Set up output handlers
+        if (childProcess.stdout) {
+            childProcess.stdout.on("data", (data) => {
+                const output = data.toString("utf8");
+                logger.debug({ output }, `Background command (pid ${pid}) output:`);
+                if (options.onOutput) {
+                    options.onOutput(output);
+                }
+            });
+        }
+        if (childProcess.stderr) {
+            childProcess.stderr.on("data", (data) => {
+                const errorOutput = data.toString("utf8");
+                logger.debug({ errorOutput }, `Background command (pid ${pid}) error:`);
+                if (options.onError) {
+                    options.onError(errorOutput);
+                }
+            });
+        }
+        // Set up exit handler
+        childProcess.on("exit", (code) => {
+            isRunning = false;
+            logger.debug(`Background command (pid ${pid}) exited with code ${code}`);
+            // Remove from tracked processes
+            this.backgroundProcesses.delete(pid);
+            // Clean up abort listener
+            if (abortHandler) {
+                options.abortSignal?.removeEventListener("abort", abortHandler);
+            }
+            if (options.onExit) {
+                options.onExit(code);
+            }
+        });
+        // Handle abort signal for background process
+        let abortHandler;
+        if (options.abortSignal) {
+            abortHandler = () => {
+                logger.warn({ command, pid }, "Background command execution aborted");
+                if (isRunning) {
+                    childProcess.kill("SIGTERM");
+                    isRunning = false;
+                    this.backgroundProcesses.delete(pid);
+                }
+            };
+            options.abortSignal.addEventListener("abort", abortHandler, {
+                once: true,
+            });
+        }
+        // Create the process handle
+        const backgroundProcess = {
+            pid,
+            kill: () => {
+                if (isRunning) {
+                    childProcess.kill();
+                    isRunning = false;
+                    this.backgroundProcesses.delete(pid);
+                    // Clean up abort listener
+                    if (abortHandler) {
+                        options.abortSignal?.removeEventListener("abort", abortHandler);
+                    }
+                    return true;
+                }
+                return false;
+            },
+            isRunning: true,
+        };
+        // Track the process
+        this.backgroundProcesses.set(pid, backgroundProcess);
+        return backgroundProcess;
+    }
+    /**
+     * Kill all running background processes
+     */
+    killAllBackgroundProcesses() {
+        logger.info(`Killing ${this.backgroundProcesses.size} background processes`);
+        for (const process of this.backgroundProcesses.values()) {
+            try {
+                process.kill();
+            }
+            catch (error) {
+                logger.warn(error, `Failed to kill process ${process.pid}`);
+            }
+        }
+        this.backgroundProcesses.clear();
+    }
+    /**
+     * Validate a command for safety
+     */
+    validateCommand(command) {
+        // Check if command is in the denied list
+        for (const pattern of DANGEROUS_COMMANDS) {
+            if (pattern.test(command)) {
+                throw new Error(`Command execution blocked: '${command}' matches dangerous pattern`);
+            }
+        }
+        // Check if command is in allowed list (if configured)
+        if (this.config.execution?.allowedCommands &&
+            this.config.execution.allowedCommands.length > 0) {
+            const allowed = this.config.execution.allowedCommands.some((allowedPattern) => {
+                if (typeof allowedPattern === "string") {
+                    return command.startsWith(allowedPattern);
+                }
+                return allowedPattern.test(command);
+            });
+            if (!allowed) {
+                throw new Error(`Command execution blocked: '${command}' is not in the allowed list`);
+            }
+        }
+    }
+    /**
+     * Set the working directory
+     */
+    setWorkingDirectory(directory) {
+        this.workingDirectory = directory;
+        logger.debug(`Working directory set to: ${directory}`);
+    }
+    /**
+     * Get the working directory
+     */
+    getWorkingDirectory() {
+        return this.workingDirectory;
+    }
+    /**
+     * Set an environment variable
+     */
+    setEnvironmentVariable(name, value) {
+        this.environmentVariables[name] = value;
+        logger.debug(`Environment variable set: ${name}=${value}`);
+    }
+    /**
+     * Get an environment variable
+     */
+    getEnvironmentVariable(name) {
+        return this.environmentVariables[name];
+    }
+}
+/**
+ * Initialize the execution environment
+ */
+export async function initExecutionEnvironment(config = {}) {
+    logger.info("Initializing execution environment");
+    try {
+        const executionEnv = new ExecutionEnvironment(config);
+        await executionEnv.initialize();
+        logger.info("Execution environment initialized successfully");
+        return executionEnv;
+    }
+    catch (error) {
+        logger.error(error, "Failed to initialize execution environment");
+        // Return a minimal execution environment even if initialization failed
+        return new ExecutionEnvironment(config);
+    }
+}
+// const platformName = process.platform;
+// let cmd: string;
+// let args: string[] = [];
+// const useShellOption = false;
+// if (platformName === "win32") {
+//   const { execSync } = await import("node:child_process");
+//   try {
+//     execSync("where wsl", { stdio: "ignore" });
+//     cmd = "wsl.exe";
+//     args = ["--", command];
+//   } catch {
+//     cmd = "powershell.exe";
+//     args = ["-NoProfile", "-NonInteractive", "-Command", command];
+//   }
+// } else {
+//   const shell = process.env["SHELL"] || "/bin/bash";
+//   cmd = shell;
+//   args = ["-c", command];
+// }
+// Set up cleanup on process exit
+export function setupProcessCleanup(executionEnv) {
+    process.on("exit", () => {
+        executionEnv.killAllBackgroundProcesses();
+    });
+    process.on("SIGINT", () => {
+        executionEnv.killAllBackgroundProcesses();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        executionEnv.killAllBackgroundProcesses();
+        process.exit(0);
+    });
+}

package/dist/formatting.d.ts

@@ -1,17 +1,6 @@
-/**
- * Extracts the first code block content from the given text.
- * If a Markdown-style triple backtick code block is found, returns its inner content.
- * Otherwise, returns the original text unchanged.
- *
- * @param text - The input string potentially containing a Markdown code block.
- * @returns The extracted code inside the first code block, or the original text if no block is found.
- */
-export declare const extractCodeBlock: (text: string) => string;
-export declare function extractXml(text: string, tag: string): string;
-export declare function removeAllLineBreaks(text: string): string;
-export declare function removeHtmlTags(text: string): string;
 export type FormatType = "xml" | "markdown" | "bracket";
 export declare function formatFile(file: string, content: string, format: FormatType): string;
 export declare function formatUrl(siteUrl: string, content: string, format: FormatType): string;
-export declare function formatCodeSnippet(file: string, content: string, format: FormatType): string;
+export declare function formatCodeBlock(file: string, content: string): string;
 export declare function formatBlock(content: string, blockName: string, format: FormatType): string;
+//# sourceMappingURL=formatting.d.ts.map

package/dist/formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../source/formatting.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,SAAS,CAAC;AAExD,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAaR;AAED,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAIrE;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,UAAU,GACjB,MAAM,CAWR"}

package/dist/formatting.js

@@ -1,57 +1,8 @@
 import path from "node:path";
-const MD_CODE_BLOCK = /```(?:[\w-]+)?\n(.*?)```/s;
-/**
- * Extracts the first code block content from the given text.
- * If a Markdown-style triple backtick code block is found, returns its inner content.
- * Otherwise, returns the original text unchanged.
- *
- * @param text - The input string potentially containing a Markdown code block.
- * @returns The extracted code inside the first code block, or the original text if no block is found.
- */
-export const extractCodeBlock = (text) => {
-    const pattern = MD_CODE_BLOCK;
-    const match = text.match(pattern);
-    if (match) {
-        return match[1] ?? "";
-    }
-    return text;
-};
-export function extractXml(text, tag) {
-    const match = text.match(new RegExp(`<${tag}>(.*?)</${tag}>`, "s"));
-    return match ? (match[1] ?? "") : "";
-}
-export function removeAllLineBreaks(text) {
-    return text.replace(/(\r\n|\n|\r)/gm, " ");
-}
-export function removeHtmlTags(text) {
-    return text.replace(/<[^>]*>?/gm, "");
-}
+import { getCodeblockFromFilePath } from "./utils/filetype-detection.js";
 const MD_TRIPLE_QUOTE = "```";
-const codeBlockExtensions = {
-    js: "javascript",
-    ts: "typescript",
-    py: "python",
-    rb: "ruby",
-    java: "java",
-    cpp: "cpp",
-    cs: "csharp",
-    go: "go",
-    rs: "rust",
-    php: "php",
-    html: "html",
-    css: "css",
-    json: "json",
-    yml: "yaml",
-    yaml: "yaml",
-    md: "markdown",
-    sql: "sql",
-    sh: "bash",
-    bash: "bash",
-    txt: "text",
-};
 export function formatFile(file, content, format) {
-    const fileExtension = path.extname(file).slice(1);
-    const codeBlockName = codeBlockExtensions[fileExtension] || fileExtension;
+    const codeBlockName = getCodeblockFromFilePath(file) || path.extname(file).slice(1);
     switch (format) {
         case "xml":
             return `<file>\n<name>${file}</name>\n<content>\n${content}\n</content>\n</file>`;
@@ -75,19 +26,9 @@ export function formatUrl(siteUrl, content, format) {
             throw new Error(`Unsupported format: ${format}`);
     }
 }
-export function formatCodeSnippet(file, content, format) {
-    const fileExtension = path.extname(file).slice(1);
-    const codeBlockName = codeBlockExtensions[fileExtension] || fileExtension;
-    switch (format) {
-        case "xml":
-            return `<code>\n${content}\n</code>`;
-        case "markdown":
-            return `${MD_TRIPLE_QUOTE} ${codeBlockName}\n${content}\n${MD_TRIPLE_QUOTE}`;
-        case "bracket":
-            return `[code begin]\n${content}\n[code end]`;
-        default:
-            throw new Error(`Unsupported format: ${format}`);
-    }
+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}`;
 }
 export function formatBlock(content, blockName, format) {
     switch (format) {

package/dist/index.d.ts

@@ -17,3 +17,4 @@ declare const flags: {
 export declare function handleError(error: Error): void;
 export type Flags = typeof flags;
 export {};
+//# sourceMappingURL=index.d.ts.map