wave-agent-sdk 0.0.8 → 0.0.11

package/dist/utils/cacheControlUtils.js

@@ -5,17 +5,10 @@
  * to optimize token usage and reduce costs. Cache control is only applied to Claude
  * models and preserves backward compatibility with existing message formats.
  */
+import { logger } from "./globalLogger.js";
 // ============================================================================
 // Default Configuration
 // ============================================================================
-/**
- * Default cache control configuration
- */
-export const DEFAULT_CACHE_CONTROL_CONFIG = {
-    cacheSystemMessage: true,
-    cacheUserMessageCount: 2,
-    cacheLastTool: true,
-};
 // ============================================================================
 // Utility Functions (Basic Structure - to be implemented)
 // ============================================================================
@@ -48,6 +41,24 @@ export function isValidCacheControl(control) {
         "type" in control &&
         control.type === "ephemeral");
 }
+/**
+ * Adds cache control to the last tool call in an array
+ * @param toolCalls - Array of tool calls
+ * @returns Tool calls array with cache control on the last tool call
+ */
+function addCacheControlToLastToolCall(toolCalls) {
+    if (!toolCalls || toolCalls.length === 0) {
+        return toolCalls;
+    }
+    const result = [...toolCalls];
+    const lastIndex = result.length - 1;
+    // Add cache control to the last tool call
+    result[lastIndex] = {
+        ...result[lastIndex],
+        cache_control: { type: "ephemeral" },
+    };
+    return result;
+}
 /**
  * Adds cache control markers to message content
  * @param content - Original content (string or structured)
@@ -66,7 +77,7 @@ export function addCacheControlToContent(content, shouldCache) {
         }
         // Validate array input
         if (!Array.isArray(content)) {
-            console.warn("Invalid content type for cache control transformation:", typeof content);
+            logger.warn("Invalid content type for cache control transformation:", typeof content);
             return [];
         }
         // Filter and convert only text parts with validation
@@ -92,7 +103,7 @@ export function addCacheControlToContent(content, shouldCache) {
     }
     // Validate array input
     if (!Array.isArray(content)) {
-        console.warn("Invalid content type for cache control transformation:", typeof content);
+        logger.warn("Invalid content type for cache control transformation:", typeof content);
         return [];
     }
     // Handle structured content - preserve existing structure, add cache control to text parts
@@ -122,17 +133,17 @@ export function addCacheControlToLastTool(tools) {
     // Validate tools structure
     const validTools = tools.filter((tool) => {
         if (!tool || typeof tool !== "object") {
-            console.warn("Invalid tool structure detected, skipping:", tool);
+            logger.warn("Invalid tool structure detected, skipping:", tool);
             return false;
         }
         if (tool.type !== "function" || !tool.function) {
-            console.warn("Tool is not a function type or missing function property:", tool);
+            logger.warn("Tool is not a function type or missing function property:", tool);
             return false;
         }
         return true;
     });
     if (validTools.length === 0) {
-        console.warn("No valid tools found for cache control");
+        logger.warn("No valid tools found for cache control");
         return [];
     }
     // Create a copy of the valid tools array
@@ -148,16 +159,37 @@ export function addCacheControlToLastTool(tools) {
     return result;
 }
 /**
- * Transforms messages for Claude cache control
+ * Finds the latest message index at 20-message intervals (sliding window approach)
+ * @param messages - Array of chat completion messages
+ * @returns Index of the latest interval message (20th, 40th, 60th, etc.) or -1 if none
+ */
+export function findIntervalMessageIndex(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return -1;
+    }
+    const interval = 20; // Hardcoded interval
+    const messageCount = messages.length;
+    // Find the largest interval that fits within the message count
+    // Math.floor(messageCount / interval) gives us how many complete intervals we have
+    // Multiply by interval to get the position of the latest interval message
+    const latestIntervalPosition = Math.floor(messageCount / interval) * interval;
+    // If no complete intervals exist, return -1
+    if (latestIntervalPosition === 0) {
+        return -1;
+    }
+    // Convert from 1-based position to 0-based index
+    return latestIntervalPosition - 1;
+}
+/**
+ * Transforms messages for Claude cache control with hardcoded strategy
  * @param messages - Original OpenAI message array
  * @param modelName - Model name for cache detection
- * @param config - Cache control configuration
  * @returns Messages with cache control markers applied
  */
-export function transformMessagesForClaudeCache(messages, modelName, config = DEFAULT_CACHE_CONTROL_CONFIG) {
+export function transformMessagesForClaudeCache(messages, modelName) {
     // Validate inputs
     if (!messages || !Array.isArray(messages)) {
-        console.warn("Invalid messages array provided to transformMessagesForClaudeCache");
+        logger.warn("Invalid messages array provided to transformMessagesForClaudeCache");
         return [];
     }
     if (messages.length === 0) {
@@ -167,40 +199,52 @@ export function transformMessagesForClaudeCache(messages, modelName, config = DE
     if (!isClaudeModel(modelName)) {
         return messages;
     }
-    // Validate config
-    if (!config || typeof config !== "object") {
-        console.warn("Invalid cache control config, using defaults");
-        config = DEFAULT_CACHE_CONTROL_CONFIG;
+    // Find the latest interval message index (20th, 40th, 60th, etc.)
+    const intervalMessageIndex = findIntervalMessageIndex(messages);
+    // Find last system message index
+    let lastSystemIndex = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "system") {
+            lastSystemIndex = i;
+            break;
+        }
     }
     const result = messages.map((message, index) => {
         // Validate message structure
         if (!message || typeof message !== "object" || !message.role) {
-            console.warn("Invalid message structure at index", index, ":", message);
+            logger.warn("Invalid message structure at index", index, ":", message);
             return message; // Return as-is to avoid breaking the flow
         }
-        // System message: cache if enabled in config
-        if (message.role === "system" && config.cacheSystemMessage) {
+        // Last system message: always cached (hardcoded)
+        if (message.role === "system" && index === lastSystemIndex) {
             return {
                 ...message,
-                content: addCacheControlToContent(message.content, true),
+                content: addCacheControlToContent(message.content || "", true),
             };
         }
-        // User messages: cache last N messages based on config
-        if (message.role === "user" && config.cacheUserMessageCount > 0) {
-            const userMessageIndices = [];
-            messages.forEach((msg, idx) => {
-                if (msg.role === "user") {
-                    userMessageIndices.push(idx);
-                }
-            });
-            // Check if this user message is among the last N
-            const isRecentUser = userMessageIndices
-                .slice(-config.cacheUserMessageCount)
-                .includes(index);
-            if (isRecentUser) {
+        // Interval-based message caching: cache message at latest interval position (sliding window)
+        if (index === intervalMessageIndex) {
+            // If the message is a tool role, add cache control directly to the message
+            if (message.role === "tool") {
+                return {
+                    ...message,
+                    cache_control: { type: "ephemeral" },
+                };
+            }
+            // If the message has tool calls, cache the last tool call instead of content
+            else if (message.role === "assistant" &&
+                message.tool_calls &&
+                message.tool_calls.length > 0) {
+                return {
+                    ...message,
+                    tool_calls: addCacheControlToLastToolCall(message.tool_calls),
+                };
+            }
+            else {
+                // For other message types without tool calls, cache the content
                 return {
                     ...message,
-                    content: addCacheControlToContent(message.content, true),
+                    content: addCacheControlToContent(message.content || "", true),
                 };
             }
         }
@@ -278,90 +322,3 @@ export function isValidClaudeUsage(usage) {
     }
     return true;
 }
-/**
- * Adds cache control to the last N user messages in a conversation
- * This optimizes multi-turn conversations by caching recent user context
- *
- * @param messages - Array of chat completion messages
- * @param maxUserMessagesToCache - Maximum number of recent user messages to cache (default: 2)
- * @returns Modified messages array with cache control on recent user messages
- */
-export function addCacheControlToRecentUserMessages(messages, maxUserMessagesToCache = 2) {
-    // Validate inputs
-    if (!messages || !Array.isArray(messages)) {
-        console.warn("Invalid messages array provided to addCacheControlToRecentUserMessages");
-        return [];
-    }
-    if (messages.length === 0 || maxUserMessagesToCache <= 0) {
-        return messages;
-    }
-    // Validate maxUserMessagesToCache is a reasonable number
-    if (maxUserMessagesToCache > 100) {
-        console.warn("maxUserMessagesToCache is unusually high:", maxUserMessagesToCache, "limiting to 100");
-        maxUserMessagesToCache = 100;
-    }
-    // Find all user message indices in reverse order (most recent first)
-    const userMessageIndices = [];
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        // Validate message structure
-        if (!message || typeof message !== "object" || !message.role) {
-            console.warn("Invalid message at index", i, ", skipping");
-            continue;
-        }
-        if (message.role === "user") {
-            userMessageIndices.push(i);
-            if (userMessageIndices.length >= maxUserMessagesToCache) {
-                break;
-            }
-        }
-    }
-    // If no user messages found, return unchanged
-    if (userMessageIndices.length === 0) {
-        return messages;
-    }
-    // Create a copy of messages and modify the identified user messages
-    const modifiedMessages = [...messages];
-    for (const index of userMessageIndices) {
-        const message = modifiedMessages[index];
-        if (message.role === "user" && message.content != null) {
-            try {
-                modifiedMessages[index] = {
-                    ...message,
-                    content: addCacheControlToContent(message.content, true),
-                };
-            }
-            catch (error) {
-                console.warn("Failed to add cache control to user message at index", index, ":", error);
-                // Continue with original message if transformation fails
-            }
-        }
-    }
-    return modifiedMessages;
-}
-/**
- * Helper function to identify user message indices that should be cached
- * Used for testing and validation purposes
- *
- * @param messages - Array of chat completion messages
- * @param maxUserMessagesToCache - Maximum number of recent user messages to identify
- * @returns Array of indices for user messages that should be cached
- */
-export function findRecentUserMessageIndices(messages, maxUserMessagesToCache = 2) {
-    if (!Array.isArray(messages) ||
-        messages.length === 0 ||
-        maxUserMessagesToCache <= 0) {
-        return [];
-    }
-    const userMessageIndices = [];
-    for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i].role === "user") {
-            userMessageIndices.push(i);
-            if (userMessageIndices.length >= maxUserMessagesToCache) {
-                break;
-            }
-        }
-    }
-    // Return indices in original order (not reversed)
-    return userMessageIndices.reverse();
-}

package/dist/utils/constants.d.ts

@@ -22,16 +22,4 @@ export declare const USER_MEMORY_FILE: string;
  * AI related constants
  */
 export declare const DEFAULT_TOKEN_LIMIT = 96000;
-/**
- * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
- * They are maintained for backward compatibility with existing code that might still reference them,
- * but the actual AI services now use configuration injection.
- */
-export declare const FAST_MODEL_ID: string;
-/**
- * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
- * They are maintained for backward compatibility with existing code that might still reference them,
- * but the actual AI services now use configuration injection.
- */
-export declare const AGENT_MODEL_ID: string;
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAmC,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAiD,CAAC;AAEhF;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAA0C,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAA8C,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,aAAa,QAAoD,CAAC;AAE/E;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAC2B,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;GAGG;AACH,eAAO,MAAM,cAAc,QAAmC,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAiD,CAAC;AAEhF;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAA0C,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAyC,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAAQ,CAAC"}

package/dist/utils/constants.js

@@ -19,20 +19,8 @@ export const ERROR_LOG_DIRECTORY = path.join(DATA_DIRECTORY, "error-logs");
 /**
  * User-level memory file path
  */
-export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "user-memory.md");
+export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
 /**
  * AI related constants
  */
 export const DEFAULT_TOKEN_LIMIT = 96000; // Default token limit
-/**
- * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
- * They are maintained for backward compatibility with existing code that might still reference them,
- * but the actual AI services now use configuration injection.
- */
-export const FAST_MODEL_ID = process.env.AIGW_FAST_MODEL || "gemini-2.5-flash";
-/**
- * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
- * They are maintained for backward compatibility with existing code that might still reference them,
- * but the actual AI services now use configuration injection.
- */
-export const AGENT_MODEL_ID = process.env.AIGW_MODEL || "claude-sonnet-4-20250514";

package/dist/utils/convertMessagesForAPI.d.ts

@@ -1,7 +1,8 @@
 import type { Message } from "../types/index.js";
 import { ChatCompletionMessageParam } from "openai/resources.js";
 /**
- * Convert message format to API call format, stopping when a compressed message is encountered
+ * Convert message format to API call format, stopping when a compressed message is encountered.
+ * Messages with no meaningful content or tool calls are filtered out.
  * @param messages Message list
  * @returns Converted API message format list
  */

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

@@ -1 +1 @@
-{"version":3,"file":"convertMessagesForAPI.d.ts","sourceRoot":"","sources":["../../src/utils/convertMessagesForAPI.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAIjD,OAAO,EAEL,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAwB7B;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,OAAO,EAAE,GAClB,0BAA0B,EAAE,CA+L9B"}
+{"version":3,"file":"convertMessagesForAPI.d.ts","sourceRoot":"","sources":["../../src/utils/convertMessagesForAPI.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAIjD,OAAO,EAEL,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAwB7B;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,OAAO,EAAE,GAClB,0BAA0B,EAAE,CAsN9B"}

package/dist/utils/convertMessagesForAPI.js

@@ -22,7 +22,8 @@ function safeToolArguments(args) {
     }
 }
 /**
- * Convert message format to API call format, stopping when a compressed message is encountered
+ * Convert message format to API call format, stopping when a compressed message is encountered.
+ * Messages with no meaningful content or tool calls are filtered out.
  * @param messages Message list
  * @returns Converted API message format list
  */
@@ -44,7 +45,7 @@ export function convertMessagesForAPI(messages) {
             }
             break;
         }
-        // Skip empty assistant messages
+        // Skip empty assistant messages (no blocks or all blocks are empty)
         if (message.role === "assistant" && message.blocks.length === 0) {
             continue;
         }
@@ -101,10 +102,14 @@ export function convertMessagesForAPI(messages) {
             // Construct the content of the assistant message
             let content = "";
             let tool_calls = undefined;
-            // Construct content from text blocks
-            const textBlocks = message.blocks.filter((block) => block.type === "text");
+            // Construct content from text blocks - filter out empty content
+            const textBlocks = message.blocks.filter((block) => block.type === "text" &&
+                block.content &&
+                block.content.trim().length > 0);
             if (textBlocks.length > 0) {
-                content = textBlocks.map((block) => block.content || "").join("\n");
+                content = textBlocks
+                    .map((block) => (block.type === "text" ? block.content : ""))
+                    .join("\n");
             }
             // Construct tool calls from tool blocks
             if (toolBlocks.length > 0) {
@@ -122,13 +127,15 @@ export function convertMessagesForAPI(messages) {
                     tool_calls = undefined;
                 }
             }
-            // Construct assistant message - only add if there is content or tool calls
-            if (content || tool_calls) {
+            // Construct assistant message - only add if there is meaningful content or tool calls
+            const hasContent = content && content.trim().length > 0;
+            const hasToolCalls = tool_calls && tool_calls.length > 0;
+            if (hasContent || hasToolCalls) {
                 const assistantMessage = {
                     role: "assistant",
-                    content,
+                    content: hasContent ? content : undefined,
                     tool_calls,
-                    ...(message.metadata ? { ...message.metadata } : {}),
+                    ...(message.additionalFields ? { ...message.additionalFields } : {}),
                 };
                 recentMessages.unshift(assistantMessage);
             }
@@ -137,8 +144,10 @@ export function convertMessagesForAPI(messages) {
             // User messages converted to standard format
             const contentParts = [];
             message.blocks.forEach((block) => {
-                // Add text content
-                if (block.type === "text" && block.content) {
+                // Add text content - only if it has meaningful content
+                if (block.type === "text" &&
+                    block.content &&
+                    block.content.trim().length > 0) {
                     contentParts.push({
                         type: "text",
                         text: block.customCommandContent || block.content,
@@ -172,11 +181,21 @@ export function convertMessagesForAPI(messages) {
                     });
                 }
             });
+            // Only add user message if there is meaningful content
             if (contentParts.length > 0) {
-                recentMessages.unshift({
-                    role: "user",
-                    content: contentParts,
+                // Filter out empty text parts
+                const meaningfulParts = contentParts.filter((part) => {
+                    if (part.type === "text") {
+                        return part.text && part.text.trim().length > 0;
+                    }
+                    return true; // Keep image parts
                 });
+                if (meaningfulParts.length > 0) {
+                    recentMessages.unshift({
+                        role: "user",
+                        content: meaningfulParts,
+                    });
+                }
             }
         }
     }

package/dist/utils/fileSearch.d.ts

@@ -0,0 +1,14 @@
+import { type Path } from "glob";
+import type { FileItem } from "../types/fileSearch.js";
+/**
+ * Convert Path objects to FileItem objects
+ */
+export declare const convertPathsToFileItems: (paths: Path[]) => FileItem[];
+/**
+ * Search files and directories using glob patterns
+ */
+export declare const searchFiles: (query: string, options?: {
+    maxResults?: number;
+    workingDirectory?: string;
+}) => Promise<FileItem[]>;
+//# sourceMappingURL=fileSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fileSearch.d.ts","sourceRoot":"","sources":["../../src/utils/fileSearch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAE9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,IAAI,EAAE,KAAG,QAAQ,EAK/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,MAAM,EACb,UAAU;IACR,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,KACA,OAAO,CAAC,QAAQ,EAAE,CAmFpB,CAAC"}

package/dist/utils/fileSearch.js

@@ -0,0 +1,88 @@
+import { globIterate } from "glob";
+import { getGlobIgnorePatterns } from "./fileFilter.js";
+/**
+ * Convert Path objects to FileItem objects
+ */
+export const convertPathsToFileItems = (paths) => {
+    return paths.map((pathObj) => ({
+        path: pathObj.relative(),
+        type: pathObj.isDirectory() ? "directory" : "file",
+    }));
+};
+/**
+ * Search files and directories using glob patterns
+ */
+export const searchFiles = async (query, options) => {
+    const { maxResults = 10, workingDirectory = process.cwd() } = options || {};
+    try {
+        const globOptions = {
+            ignore: getGlobIgnorePatterns(workingDirectory),
+            maxDepth: 10,
+            nocase: true, // Case insensitive
+            dot: true, // Include hidden files and directories
+            cwd: workingDirectory, // Specify search root directory
+            withFileTypes: true, // Get Path objects instead of strings
+        };
+        // Build glob patterns based on query
+        let patterns = [];
+        if (!query.trim()) {
+            // When query is empty, show some common file types and directories
+            patterns = [
+                "**/*.{ts,tsx,js,jsx,json,py,java}", // Combine common file extensions
+                "*/", // First level directories
+            ];
+        }
+        else {
+            // Build multiple glob patterns to support more flexible search
+            patterns = [
+                // Match files with filenames containing query
+                `**/*${query}*`,
+                // Match files with query in path (match directory names)
+                `**/${query}*/**/*`,
+                // Match directory names containing query
+                `**/*${query}*/`,
+                // Match directories containing query in path
+                `**/${query}*/`,
+            ];
+        }
+        // Collect results until we reach maxResults
+        const collectedPaths = [];
+        const seenPaths = new Set();
+        // Process each pattern sequentially
+        for (const pattern of patterns) {
+            if (collectedPaths.length >= maxResults) {
+                break;
+            }
+            // Use globIterate to get results one by one
+            const iterator = globIterate(pattern, globOptions);
+            for await (const pathObj of iterator) {
+                if (collectedPaths.length >= maxResults) {
+                    // Stop the iterator when we have enough results
+                    break;
+                }
+                const relativePath = pathObj.relative();
+                if (!seenPaths.has(relativePath)) {
+                    seenPaths.add(relativePath);
+                    collectedPaths.push(pathObj);
+                }
+            }
+        }
+        // Sort collected paths: directories first, then files
+        collectedPaths.sort((a, b) => {
+            const aIsDir = a.isDirectory();
+            const bIsDir = b.isDirectory();
+            if (aIsDir && !bIsDir)
+                return -1;
+            if (!aIsDir && bIsDir)
+                return 1;
+            return a.relative().localeCompare(b.relative());
+        });
+        // Convert to FileItems
+        const fileItems = convertPathsToFileItems(collectedPaths);
+        return fileItems;
+    }
+    catch (error) {
+        console.error("Glob search error:", error);
+        return [];
+    }
+};

package/dist/utils/fileUtils.d.ts

@@ -6,10 +6,22 @@
  */
 export declare function readFirstLine(filePath: string): Promise<string>;
 /**
- * Reads a file from the end and returns the first non-empty line.
+ * Reads a file from the end and returns the last non-empty line.
+ *
+ * This version supports files that end with:
+ *   - "\n" (Unix-style, including modern macOS)
+ *   - "\r\n" (Windows-style)
+ *   - "\r" (older Mac-style, HL7, etc.)
  *
  * @param {string} filePath - The path to the file.
+ * @param {number} [minLength=1] - Minimum length for the returned line.
  * @return {Promise<string>} - The last non-empty line of the file, or an empty string if no non-empty lines found.
  */
-export declare function getLastLine(filePath: string): Promise<string>;
+export declare function getLastLine(filePath: string, minLength?: number): Promise<string>;
+/**
+ * Ensures that a pattern is present in the global git ignore file.
+ *
+ * @param {string} pattern - The pattern to add to global git ignore.
+ */
+export declare function ensureGlobalGitIgnore(pattern: string): Promise<void>;
 //# sourceMappingURL=fileUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fileUtils.d.ts","sourceRoot":"","sources":["../../src/utils/fileUtils.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBrE;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBnE"}
+{"version":3,"file":"fileUtils.d.ts","sourceRoot":"","sources":["../../src/utils/fileUtils.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,SAAS,SAAI,GACZ,OAAO,CAAC,MAAM,CAAC,CA8DjB;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqC1E"}