wave-agent-sdk 0.0.1

package/dist/utils/markdownParser.js

@@ -0,0 +1,109 @@
+import { readFileSync } from "fs";
+/**
+ * Parse YAML frontmatter from markdown content
+ */
+function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+        return { content };
+    }
+    const [, frontmatterStr, bodyContent] = match;
+    try {
+        // Simple YAML parser for our use case (only supports key: value pairs)
+        const frontmatter = {};
+        const lines = frontmatterStr.split("\n");
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith("#"))
+                continue;
+            const colonIndex = trimmedLine.indexOf(":");
+            if (colonIndex === -1)
+                continue;
+            const key = trimmedLine.slice(0, colonIndex).trim();
+            const value = trimmedLine.slice(colonIndex + 1).trim();
+            // Handle array values for allowed-tools
+            if (key === "allowed-tools" && value) {
+                // Simple array parsing: "tool1, tool2, tool3" or "[tool1, tool2]"
+                let arrayValue = value;
+                if (arrayValue.startsWith("[") && arrayValue.endsWith("]")) {
+                    arrayValue = arrayValue.slice(1, -1);
+                }
+                frontmatter[key] = arrayValue
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+            }
+            else if (value) {
+                frontmatter[key] = value;
+            }
+        }
+        return { frontmatter, content: bodyContent };
+    }
+    catch {
+        // If parsing fails, just return the content without frontmatter
+        return { content };
+    }
+}
+/**
+ * Parse markdown file and extract config and content
+ */
+export function parseMarkdownFile(filePath) {
+    try {
+        const fileContent = readFileSync(filePath, "utf-8");
+        const { frontmatter, content } = parseFrontmatter(fileContent);
+        let config;
+        if (frontmatter) {
+            config = {};
+            if (frontmatter["allowed-tools"] &&
+                Array.isArray(frontmatter["allowed-tools"])) {
+                config.allowedTools = frontmatter["allowed-tools"];
+            }
+            if (frontmatter.model && typeof frontmatter.model === "string") {
+                config.model = frontmatter.model;
+            }
+            if (frontmatter.description &&
+                typeof frontmatter.description === "string") {
+                config.description = frontmatter.description;
+            }
+        }
+        return {
+            content: content.trim(),
+            config,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to parse markdown file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function parseBashCommands(content) {
+    const bashCommandRegex = /!`([^`]+)`/g;
+    const commands = [];
+    let match;
+    // Extract all bash commands
+    while ((match = bashCommandRegex.exec(content)) !== null) {
+        commands.push(match[1]);
+    }
+    // For now, return the content as-is. The actual command execution
+    // will be handled by the slash command manager
+    return {
+        commands,
+        processedContent: content,
+    };
+}
+/**
+ * Replace bash command placeholders with their outputs
+ */
+export function replaceBashCommandsWithOutput(content, results) {
+    const bashCommandRegex = /!`([^`]+)`/g;
+    let processedContent = content;
+    let commandIndex = 0;
+    processedContent = processedContent.replace(bashCommandRegex, (match) => {
+        if (commandIndex < results.length) {
+            const result = results[commandIndex++];
+            return `\`\`\`\n$ ${result.command}\n${result.output}\n\`\`\``;
+        }
+        return match;
+    });
+    return processedContent;
+}

package/dist/utils/mcpUtils.d.ts

@@ -0,0 +1,24 @@
+import { ChatCompletionFunctionTool } from "openai/resources.js";
+import type { ToolPlugin } from "../tools/types.js";
+import type { McpTool, McpServerStatus } from "../types.js";
+/**
+ * Convert MCP tool to OpenAI function tool format
+ */
+export declare function mcpToolToOpenAITool(mcpTool: McpTool, serverName: string): ChatCompletionFunctionTool;
+/**
+ * Create a tool plugin wrapper for an MCP tool
+ */
+export declare function createMcpToolPlugin(mcpTool: McpTool, serverName: string, executeTool: (name: string, args: Record<string, unknown>) => Promise<{
+    success: boolean;
+    content: string;
+    serverName?: string;
+    images?: Array<{
+        data: string;
+        mediaType?: string;
+    }>;
+}>): ToolPlugin;
+/**
+ * Find which server a tool belongs to
+ */
+export declare function findToolServer(toolName: string, servers: McpServerStatus[]): McpServerStatus | undefined;
+//# sourceMappingURL=mcpUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcpUtils.d.ts","sourceRoot":"","sources":["../../src/utils/mcpUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE5D;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,GACjB,0BAA0B,CAa5B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B,OAAO,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtD,CAAC,GACD,UAAU,CA2BZ;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,eAAe,EAAE,GACzB,eAAe,GAAG,SAAS,CAK7B"}

package/dist/utils/mcpUtils.js

@@ -0,0 +1,51 @@
+/**
+ * Convert MCP tool to OpenAI function tool format
+ */
+export function mcpToolToOpenAITool(mcpTool, serverName) {
+    // Remove $schema field if it exists, as OpenAI API doesn't accept it
+    const cleanInputSchema = { ...mcpTool.inputSchema };
+    delete cleanInputSchema.$schema;
+    return {
+        type: "function",
+        function: {
+            name: mcpTool.name,
+            description: `${mcpTool.description || `Tool from MCP server ${serverName}`} (MCP: ${serverName})`,
+            parameters: cleanInputSchema,
+        },
+    };
+}
+/**
+ * Create a tool plugin wrapper for an MCP tool
+ */
+export function createMcpToolPlugin(mcpTool, serverName, executeTool) {
+    return {
+        name: mcpTool.name,
+        config: mcpToolToOpenAITool(mcpTool, serverName),
+        async execute(args, context) {
+            try {
+                // Context is available for future use when MCP tools need execution context
+                if (context) {
+                    // Future: Could pass working directory or other context to MCP tools
+                }
+                const result = await executeTool(mcpTool.name, args);
+                return {
+                    success: true,
+                    content: result.content || `Executed ${mcpTool.name}`,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    content: "",
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    };
+}
+/**
+ * Find which server a tool belongs to
+ */
+export function findToolServer(toolName, servers) {
+    return servers.find((s) => s.status === "connected" && s.tools?.some((t) => t.name === toolName));
+}

package/dist/utils/messageOperations.d.ts

@@ -0,0 +1,118 @@
+import type { Message } from "../types.js";
+import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
+export interface AddUserMessageParams {
+    messages: Message[];
+    content: string;
+    images?: Array<{
+        path: string;
+        mimeType: string;
+    }>;
+    customCommandBlock?: {
+        type: "custom_command";
+        commandName: string;
+        content: string;
+        originalInput?: string;
+    };
+}
+export interface UpdateToolBlockParams {
+    messages: Message[];
+    id: string;
+    parameters: string;
+    result?: string;
+    success?: boolean;
+    error?: string;
+    isRunning?: boolean;
+    name?: string;
+    shortResult?: string;
+    images?: Array<{
+        data: string;
+        mediaType?: string;
+    }>;
+    compactParams?: string;
+}
+export interface AgentToolBlockUpdateParams {
+    toolId: string;
+    args?: string;
+    result?: string;
+    success?: boolean;
+    error?: string;
+    isRunning?: boolean;
+    name?: string;
+    shortResult?: string;
+    compactParams?: string;
+}
+export interface AddDiffBlockParams {
+    messages: Message[];
+    path: string;
+    diffResult: Array<{
+        value: string;
+        added?: boolean;
+        removed?: boolean;
+    }>;
+}
+export interface AddErrorBlockParams {
+    messages: Message[];
+    error: string;
+}
+export interface AddMemoryBlockParams {
+    messages: Message[];
+    content: string;
+    isSuccess: boolean;
+    memoryType?: "project" | "user";
+    storagePath?: string;
+}
+export interface AddCommandOutputParams {
+    messages: Message[];
+    command: string;
+}
+export interface UpdateCommandOutputParams {
+    messages: Message[];
+    command: string;
+    output: string;
+}
+export interface CompleteCommandParams {
+    messages: Message[];
+    command: string;
+    exitCode: number;
+}
+/**
+ * Extract text content from user messages in the messages array
+ */
+export declare const extractUserInputHistory: (messages: Message[]) => string[];
+/**
+ * Convert image file path to base64 format
+ * @param imagePath Image file path
+ * @returns base64 format image data URL
+ */
+export declare const convertImageToBase64: (imagePath: string) => string;
+export declare const addUserMessageToMessages: ({ messages, content, images, customCommandBlock, }: AddUserMessageParams) => Message[];
+export declare const addAssistantMessageToMessages: (messages: Message[], content?: string, toolCalls?: ChatCompletionMessageFunctionToolCall[]) => Message[];
+export declare const addDiffBlockToMessage: ({ messages, path, diffResult, }: AddDiffBlockParams) => Message[];
+export declare const updateToolBlockInMessage: ({ messages, id, parameters, result, success, error, isRunning, name, shortResult, images, compactParams, }: UpdateToolBlockParams) => Message[];
+export declare const addErrorBlockToMessage: ({ messages, error, }: AddErrorBlockParams) => Message[];
+export declare const addMemoryBlockToMessage: ({ messages, content, isSuccess, memoryType, storagePath, }: AddMemoryBlockParams) => Message[];
+/**
+ * Count valid blocks from the end
+ * Only text, image, and tool type blocks are counted
+ * @param messages Message array
+ * @param targetCount Number of valid blocks to count
+ * @returns { messageIndex: number, blockCount: number } Message index and actual counted block count
+ */
+export declare const countValidBlocksFromEnd: (messages: Message[], targetCount: number) => {
+    messageIndex: number;
+    blockCount: number;
+};
+/**
+ * Get messages to be compressed and insertion position
+ * @param messages Message array
+ * @param keepLastCount Keep the last few valid blocks uncompressed
+ * @returns { messagesToCompress: Message[], insertIndex: number }
+ */
+export declare const getMessagesToCompress: (messages: Message[], keepLastCount?: number) => {
+    messagesToCompress: Message[];
+    insertIndex: number;
+};
+export declare const addCommandOutputMessage: ({ messages, command, }: AddCommandOutputParams) => Message[];
+export declare const updateCommandOutputInMessage: ({ messages, command, output, }: UpdateCommandOutputParams) => Message[];
+export declare const completeCommandInMessage: ({ messages, command, exitCode, }: CompleteCommandParams) => Message[];
+//# sourceMappingURL=messageOperations.d.ts.map

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

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

package/dist/utils/messageOperations.js

@@ -0,0 +1,334 @@
+import { readFileSync } from "fs";
+import { extname } from "path";
+/**
+ * Extract text content from user messages in the messages array
+ */
+export const extractUserInputHistory = (messages) => {
+    return messages
+        .filter((message) => message.role === "user")
+        .map((message) => {
+        // Extract all text block content and merge
+        const textBlocks = message.blocks.filter((block) => block.type === "text");
+        return textBlocks
+            .map((block) => block.content)
+            .join(" ")
+            .trim();
+    })
+        .filter((text) => text.length > 0); // Filter out empty text
+};
+/**
+ * Convert image file path to base64 format
+ * @param imagePath Image file path
+ * @returns base64 format image data URL
+ */
+export const convertImageToBase64 = (imagePath) => {
+    try {
+        const imageBuffer = readFileSync(imagePath);
+        const ext = extname(imagePath).toLowerCase().substring(1);
+        // Determine MIME type based on file extension
+        let mimeType = "image/png"; // Default
+        switch (ext) {
+            case "jpg":
+            case "jpeg":
+                mimeType = "image/jpeg";
+                break;
+            case "png":
+                mimeType = "image/png";
+                break;
+            case "gif":
+                mimeType = "image/gif";
+                break;
+            case "webp":
+                mimeType = "image/webp";
+                break;
+            case "bmp":
+                mimeType = "image/bmp";
+                break;
+            default:
+                mimeType = "image/png";
+        }
+        const base64String = imageBuffer.toString("base64");
+        return `data:${mimeType};base64,${base64String}`;
+    }
+    catch {
+        // logger.error(`Failed to convert image to base64: ${imagePath}`, error);
+        // Return an error placeholder or throw error
+        return `data:image/png;base64,`; // Empty base64, avoid program crash
+    }
+};
+// Add user message
+export const addUserMessageToMessages = ({ messages, content, images, customCommandBlock, }) => {
+    const blocks = [];
+    // If there's a custom command block, use it instead of text content
+    if (customCommandBlock) {
+        blocks.push(customCommandBlock);
+    }
+    else {
+        blocks.push({ type: "text", content });
+    }
+    // If there are images, add image block
+    if (images && images.length > 0) {
+        const imageUrls = images.map((img) => img.path);
+        blocks.push({
+            type: "image",
+            imageUrls,
+        });
+    }
+    const userMessage = {
+        role: "user",
+        blocks,
+    };
+    return [...messages, userMessage];
+};
+// Add assistant message (support one-time addition of answer and tool calls)
+export const addAssistantMessageToMessages = (messages, content, toolCalls) => {
+    const blocks = [];
+    // If there's answer content, add text block
+    if (content) {
+        blocks.push({ type: "text", content: content });
+    }
+    // If there are tool calls, add tool blocks
+    if (toolCalls && toolCalls.length > 0) {
+        toolCalls.forEach((toolCall) => {
+            blocks.push({
+                type: "tool",
+                parameters: toolCall.function.arguments || "",
+                result: "",
+                id: toolCall.id || "",
+                name: toolCall.function?.name || "",
+                isRunning: false,
+            });
+        });
+    }
+    const initialAssistantMessage = {
+        role: "assistant",
+        blocks,
+    };
+    return [...messages, initialAssistantMessage];
+};
+// Update File Operation Block of the last assistant message
+export const addDiffBlockToMessage = ({ messages, path, diffResult, }) => {
+    const newMessages = [...messages];
+    // Find the last assistant message
+    for (let i = newMessages.length - 1; i >= 0; i--) {
+        if (newMessages[i].role === "assistant") {
+            // Directly add diff block instead of replacing existing blocks
+            newMessages[i].blocks.push({
+                type: "diff",
+                path: path,
+                diffResult: diffResult,
+            });
+            break;
+        }
+    }
+    return newMessages;
+};
+// Update Tool Block of the last assistant message
+export const updateToolBlockInMessage = ({ messages, id, parameters, result, success, error, isRunning, name, shortResult, images, compactParams, }) => {
+    const newMessages = [...messages];
+    // Find the last assistant message
+    for (let i = newMessages.length - 1; i >= 0; i--) {
+        if (newMessages[i].role === "assistant") {
+            const toolBlockIndex = newMessages[i].blocks.findIndex((block) => block.type === "tool" && block.id === id);
+            if (toolBlockIndex !== -1) {
+                const toolBlock = newMessages[i].blocks[toolBlockIndex];
+                if (toolBlock.type === "tool") {
+                    toolBlock.parameters = parameters;
+                    if (result !== undefined)
+                        toolBlock.result = result;
+                    if (shortResult !== undefined)
+                        toolBlock.shortResult = shortResult;
+                    toolBlock.images = images; // Add image data update
+                    if (success !== undefined)
+                        toolBlock.success = success;
+                    if (error !== undefined)
+                        toolBlock.error = error;
+                    if (isRunning !== undefined)
+                        toolBlock.isRunning = isRunning;
+                    if (compactParams !== undefined)
+                        toolBlock.compactParams = compactParams;
+                }
+            }
+            else if (result !== undefined) {
+                // If existing block not found, create new one
+                newMessages[i].blocks.push({
+                    type: "tool",
+                    parameters: parameters,
+                    result: result,
+                    shortResult: shortResult,
+                    images: images, // Add image data
+                    id: id,
+                    name: name || "unknown",
+                    success: success,
+                    error: error,
+                    isRunning: isRunning ?? false,
+                    compactParams: compactParams,
+                });
+            }
+            break;
+        }
+    }
+    return newMessages;
+};
+// Add Error Block to the last assistant message
+export const addErrorBlockToMessage = ({ messages, error, }) => {
+    const newMessages = [...messages];
+    // Find the last assistant message
+    let assistantMessageFound = false;
+    for (let i = newMessages.length - 1; i >= 0; i--) {
+        if (newMessages[i].role === "assistant") {
+            newMessages[i].blocks = [
+                ...newMessages[i].blocks,
+                {
+                    type: "error",
+                    content: error,
+                },
+            ];
+            assistantMessageFound = true;
+            break;
+        }
+    }
+    // If no assistant message found, create a new assistant message with only error block
+    if (!assistantMessageFound) {
+        newMessages.push({
+            role: "assistant",
+            blocks: [
+                {
+                    type: "error",
+                    content: error,
+                },
+            ],
+        });
+    }
+    return newMessages;
+};
+// Add Memory Block as new assistant message
+export const addMemoryBlockToMessage = ({ messages, content, isSuccess, memoryType, storagePath, }) => {
+    const newMessages = [...messages];
+    // Create new assistant message containing MemoryBlock
+    const memoryMessage = {
+        role: "assistant",
+        blocks: [
+            {
+                type: "memory",
+                content,
+                isSuccess,
+                memoryType,
+                storagePath,
+            },
+        ],
+    };
+    // Add to end of message list
+    newMessages.push(memoryMessage);
+    return newMessages;
+};
+/**
+ * Count valid blocks from the end
+ * Only text, image, and tool type blocks are counted
+ * @param messages Message array
+ * @param targetCount Number of valid blocks to count
+ * @returns { messageIndex: number, blockCount: number } Message index and actual counted block count
+ */
+export const countValidBlocksFromEnd = (messages, targetCount) => {
+    let validBlockCount = 0;
+    // Iterate messages from end to beginning
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        // Iterate through all blocks of current message
+        for (const block of message.blocks) {
+            // Only count valid block types
+            if (block.type === "text" ||
+                block.type === "image" ||
+                block.type === "tool") {
+                validBlockCount++;
+                // If target count reached, return current message index
+                if (validBlockCount >= targetCount) {
+                    return { messageIndex: i, blockCount: validBlockCount };
+                }
+            }
+        }
+    }
+    // If target count not reached, return index 0
+    return { messageIndex: 0, blockCount: validBlockCount };
+};
+/**
+ * Get messages to be compressed and insertion position
+ * @param messages Message array
+ * @param keepLastCount Keep the last few valid blocks uncompressed
+ * @returns { messagesToCompress: Message[], insertIndex: number }
+ */
+export const getMessagesToCompress = (messages, keepLastCount = 7) => {
+    // Calculate message position to keep from end to beginning
+    const { messageIndex } = countValidBlocksFromEnd(messages, keepLastCount);
+    // Find the last message containing compression block
+    let lastCompressIndex = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const hasCompressBlock = messages[i].blocks.some((block) => block.type === "compress");
+        if (hasCompressBlock) {
+            lastCompressIndex = i;
+            break;
+        }
+    }
+    // Determine compression start position
+    // If compression block exists, start from compression block position (include compression block)
+    // If no compression block, start from beginning
+    const startIndex = lastCompressIndex >= 0 ? lastCompressIndex : 0;
+    // Messages to compress are all messages from start position to before calculated position
+    const messagesToCompress = messages.slice(startIndex, messageIndex);
+    // Change insertion position to negative number, indicating position from end
+    const insertIndex = messageIndex - messages.length;
+    return { messagesToCompress, insertIndex };
+};
+// Add command output block to message list
+export const addCommandOutputMessage = ({ messages, command, }) => {
+    const outputMessage = {
+        role: "assistant",
+        blocks: [
+            {
+                type: "command_output",
+                command,
+                output: "",
+                isRunning: true,
+                exitCode: null,
+            },
+        ],
+    };
+    return [...messages, outputMessage];
+};
+// Update output content of command output block
+export const updateCommandOutputInMessage = ({ messages, command, output, }) => {
+    const newMessages = [...messages];
+    // Find the last assistant message with a command_output block for this command
+    for (let i = newMessages.length - 1; i >= 0; i--) {
+        const msg = newMessages[i];
+        if (msg.role === "assistant") {
+            const commandBlock = msg.blocks.find((block) => block.type === "command_output" &&
+                block.command === command &&
+                block.isRunning);
+            if (commandBlock && commandBlock.type === "command_output") {
+                commandBlock.output = output.trim();
+                break;
+            }
+        }
+    }
+    return newMessages;
+};
+// Complete command execution, update exit status
+export const completeCommandInMessage = ({ messages, command, exitCode, }) => {
+    const newMessages = [...messages];
+    // Find the last assistant message with a command_output block for this command
+    for (let i = newMessages.length - 1; i >= 0; i--) {
+        const msg = newMessages[i];
+        if (msg.role === "assistant") {
+            const commandBlock = msg.blocks.find((block) => block.type === "command_output" &&
+                block.command === command &&
+                block.isRunning);
+            if (commandBlock && commandBlock.type === "command_output") {
+                commandBlock.isRunning = false;
+                commandBlock.exitCode = exitCode;
+                break;
+            }
+        }
+    }
+    return newMessages;
+};

package/dist/utils/path.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Handle paths, supporting ~ expansion
+ * @param filePath File path
+ * @param workdir Working directory
+ * @returns Resolved absolute path
+ */
+export declare function resolvePath(filePath: string, workdir: string): string;
+/**
+ * Binary file extension list
+ */
+export declare const binaryExtensions: readonly ["png", "jpg", "jpeg", "gif", "bmp", "ico", "webp", "svg", "sketch", "mp3", "wav", "ogg", "aac", "mp4", "webm", "avi", "mov", "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "zip", "rar", "7z", "tar", "gz", "ttf", "otf", "woff", "woff2", "eot", "exe", "dll", "so", "dylib", "bin"];
+/**
+ * Check if a file is a binary file
+ * @param filename File name
+ * @returns Whether it is a binary file
+ */
+export declare const isBinary: (filename: string) => boolean;
+/**
+ * Get relative path for display, use relative path if shorter and not in parent directory
+ * @param filePath Absolute path
+ * @param workdir Working directory
+ * @returns Path for display (relative or absolute)
+ */
+export declare function getDisplayPath(filePath: string, workdir: string): string;
+//# sourceMappingURL=path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/utils/path.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAarE;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,uSA+CnB,CAAC;AACX;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAU,MAAM,KAAG,OAI3C,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAwBxE"}