@codebolt/codeboltjs 2.0.12 → 2.0.15

package/dist/notificationfunctions/browser.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Browser Notification Functions
+ *
+ * This module provides functions for sending browser-related notifications,
+ * including web fetch and web search operations.
+ */
+import { WebFetchResponseNotification, WebSearchResponseNotification } from '../types/notifications/browser';
+import { BrowserNotifications } from '../types/notificationFunctions/browser';
+/**
+ * Sends a web fetch request notification
+ *
+ * @param url - The URL to fetch
+ * @param method - Optional HTTP method
+ * @param headers - Optional headers object
+ * @param body - Optional request body
+ * @param timeout - Optional timeout in milliseconds
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 2.1 - WHEN I call `codebolt.notify.browser.WebFetchRequestNotify()` THEN the system SHALL send a WebFetchRequestNotification via WebSocket
+ */
+export declare function WebFetchRequestNotify(url: string, method?: string, headers?: Record<string, string>, body?: any, timeout?: number, toolUseId?: string): void;
+/**
+ * Sends a web fetch response notification
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data including status, statusText, headers, and url
+ *
+ * Requirements: 2.2 - WHEN I call `codebolt.notify.browser.WebFetchResponseNotify()` THEN the system SHALL send a WebFetchResponseNotification via WebSocket
+ */
+export declare function WebFetchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: WebFetchResponseNotification['data']): void;
+/**
+ * Sends a web search request notification
+ *
+ * @param query - The search query string
+ * @param maxResults - Optional maximum number of results
+ * @param searchEngine - Optional search engine to use
+ * @param filters - Optional search filters
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 2.3 - WHEN I call `codebolt.notify.browser.WebSearchRequestNotify()` THEN the system SHALL send a WebSearchRequestNotification via WebSocket
+ */
+export declare function WebSearchRequestNotify(query: string, maxResults?: number, searchEngine?: string, filters?: any, toolUseId?: string): void;
+/**
+ * Sends a web search response notification
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data including results, totalResults, and searchTime
+ *
+ * Requirements: 2.4 - WHEN I call `codebolt.notify.browser.WebSearchResponseNotify()` THEN the system SHALL send a WebSearchResponseNotification via WebSocket
+ */
+export declare function WebSearchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: WebSearchResponseNotification['data']): void;
+/**
+ * Browser notification functions object
+ */
+export declare const browserNotifications: BrowserNotifications;
+export default browserNotifications;

package/dist/notificationfunctions/browser.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Browser Notification Functions
+ *
+ * This module provides functions for sending browser-related notifications,
+ * including web fetch and web search operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserNotifications = exports.WebSearchResponseNotify = exports.WebSearchRequestNotify = exports.WebFetchResponseNotify = exports.WebFetchRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a web fetch request notification
+ *
+ * @param url - The URL to fetch
+ * @param method - Optional HTTP method
+ * @param headers - Optional headers object
+ * @param body - Optional request body
+ * @param timeout - Optional timeout in milliseconds
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 2.1 - WHEN I call `codebolt.notify.browser.WebFetchRequestNotify()` THEN the system SHALL send a WebFetchRequestNotification via WebSocket
+ */
+function WebFetchRequestNotify(url, method, headers, body, timeout, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ url }, ['url'], 'browser.WebFetchRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "browsernotify",
+        action: "webFetchRequest",
+        data: {
+            url: url,
+            method: method,
+            headers: headers,
+            body: body,
+            timeout: timeout
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'browser.WebFetchRequestNotify');
+}
+exports.WebFetchRequestNotify = WebFetchRequestNotify;
+/**
+ * Sends a web fetch response notification
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data including status, statusText, headers, and url
+ *
+ * Requirements: 2.2 - WHEN I call `codebolt.notify.browser.WebFetchResponseNotify()` THEN the system SHALL send a WebFetchResponseNotification via WebSocket
+ */
+function WebFetchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for browser.WebFetchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "browsernotify",
+        action: "webFetchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'browser.WebFetchResponseNotify');
+}
+exports.WebFetchResponseNotify = WebFetchResponseNotify;
+/**
+ * Sends a web search request notification
+ *
+ * @param query - The search query string
+ * @param maxResults - Optional maximum number of results
+ * @param searchEngine - Optional search engine to use
+ * @param filters - Optional search filters
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 2.3 - WHEN I call `codebolt.notify.browser.WebSearchRequestNotify()` THEN the system SHALL send a WebSearchRequestNotification via WebSocket
+ */
+function WebSearchRequestNotify(query, maxResults, searchEngine, filters, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ query }, ['query'], 'browser.WebSearchRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "browsernotify",
+        action: "webSearchRequest",
+        data: {
+            query: query,
+            maxResults: maxResults,
+            searchEngine: searchEngine,
+            filters: filters
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'browser.WebSearchRequestNotify');
+}
+exports.WebSearchRequestNotify = WebSearchRequestNotify;
+/**
+ * Sends a web search response notification
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data including results, totalResults, and searchTime
+ *
+ * Requirements: 2.4 - WHEN I call `codebolt.notify.browser.WebSearchResponseNotify()` THEN the system SHALL send a WebSearchResponseNotification via WebSocket
+ */
+function WebSearchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for browser.WebSearchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "browsernotify",
+        action: "webSearchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'browser.WebSearchResponseNotify');
+}
+exports.WebSearchResponseNotify = WebSearchResponseNotify;
+/**
+ * Browser notification functions object
+ */
+exports.browserNotifications = {
+    WebFetchRequestNotify,
+    WebFetchResponseNotify,
+    WebSearchRequestNotify,
+    WebSearchResponseNotify
+};
+// Default export
+exports.default = exports.browserNotifications;

package/dist/notificationfunctions/chat.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Chat Notification Functions
+ *
+ * This module provides functions for sending chat-related notifications,
+ * including user messages, agent responses, and chat history operations.
+ */
+import { AgentTextResponseNotification, GetChatHistoryRequestNotification } from '../types/notifications/chat';
+import { ChatNotifications } from '../types/notificationFunctions/chat';
+/**
+ * Sends a user message request
+ *
+ * @param message - The user message
+ * @param payload - Optional payload data
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.1 - WHEN I call `codebolt.notify.chat.UserMessageRequestNotify()` THEN the system SHALL send a UserMessageRequestNotification via WebSocket
+ */
+export declare function UserMessageRequestNotify(message: string, payload?: any, toolUseId?: string): void;
+/**
+ * Sends an agent text response
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional additional data including message, timestamp, agentId, and conversationId
+ *
+ * Requirements: 3.2 - WHEN I call `codebolt.notify.chat.AgentTextResponseNotify()` THEN the system SHALL send an AgentTextResponseNotification via WebSocket
+ */
+export declare function AgentTextResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: AgentTextResponseNotification['data']): void;
+/**
+ * Requests chat history
+ *
+ * @param data - Optional data including sessionId
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.3 - WHEN I call `codebolt.notify.chat.GetChatHistoryRequestNotify()` THEN the system SHALL send a GetChatHistoryRequestNotification via WebSocket
+ */
+export declare function GetChatHistoryRequestNotify(data?: GetChatHistoryRequestNotification['data'], toolUseId?: string): void;
+/**
+ * Sends chat history result
+ *
+ * @param content - The chat history content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.4 - WHEN I call `codebolt.notify.chat.GetChatHistoryResultNotify()` THEN the system SHALL send a GetChatHistoryResultNotification via WebSocket
+ */
+export declare function GetChatHistoryResultNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Chat notification functions object
+ */
+export declare const chatNotifications: ChatNotifications;
+export default chatNotifications;

package/dist/notificationfunctions/chat.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Chat Notification Functions
+ *
+ * This module provides functions for sending chat-related notifications,
+ * including user messages, agent responses, and chat history operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatNotifications = exports.GetChatHistoryResultNotify = exports.GetChatHistoryRequestNotify = exports.AgentTextResponseNotify = exports.UserMessageRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a user message request
+ *
+ * @param message - The user message
+ * @param payload - Optional payload data
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.1 - WHEN I call `codebolt.notify.chat.UserMessageRequestNotify()` THEN the system SHALL send a UserMessageRequestNotification via WebSocket
+ */
+function UserMessageRequestNotify(message, payload, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ message }, ['message'], 'chat.UserMessageRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "sendMessageRequest",
+        data: {
+            message: message,
+            payload: payload
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'chat.UserMessageRequestNotify');
+}
+exports.UserMessageRequestNotify = UserMessageRequestNotify;
+/**
+ * Sends an agent text response
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional additional data including message, timestamp, agentId, and conversationId
+ *
+ * Requirements: 3.2 - WHEN I call `codebolt.notify.chat.AgentTextResponseNotify()` THEN the system SHALL send an AgentTextResponseNotification via WebSocket
+ */
+function AgentTextResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for chat.AgentTextResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "agentTextResponse",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'chat.AgentTextResponseNotify');
+}
+exports.AgentTextResponseNotify = AgentTextResponseNotify;
+/**
+ * Requests chat history
+ *
+ * @param data - Optional data including sessionId
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.3 - WHEN I call `codebolt.notify.chat.GetChatHistoryRequestNotify()` THEN the system SHALL send a GetChatHistoryRequestNotification via WebSocket
+ */
+function GetChatHistoryRequestNotify(data, toolUseId) {
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "getChatHistoryRequest",
+        data: data || {}
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'chat.GetChatHistoryRequestNotify');
+}
+exports.GetChatHistoryRequestNotify = GetChatHistoryRequestNotify;
+/**
+ * Sends chat history result
+ *
+ * @param content - The chat history content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 3.4 - WHEN I call `codebolt.notify.chat.GetChatHistoryResultNotify()` THEN the system SHALL send a GetChatHistoryResultNotification via WebSocket
+ */
+function GetChatHistoryResultNotify(content, isError = false, toolUseId) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for chat.GetChatHistoryResultNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "getChatHistoryResult",
+        content: content,
+        isError: isError
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'chat.GetChatHistoryResultNotify');
+}
+exports.GetChatHistoryResultNotify = GetChatHistoryResultNotify;
+/**
+ * Chat notification functions object
+ */
+exports.chatNotifications = {
+    UserMessageRequestNotify,
+    AgentTextResponseNotify,
+    GetChatHistoryRequestNotify,
+    GetChatHistoryResultNotify
+};
+// Default export
+exports.default = exports.chatNotifications;

package/dist/notificationfunctions/codeutils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Code Utils Notification Functions
+ *
+ * This module provides functions for sending code utilities-related notifications,
+ * including grep search and glob search operations.
+ */
+import { GrepSearchResponseNotification, GlobSearchResponseNotification } from '../types/notifications/codeutils';
+import { CodeutilsNotifications } from '../types/notificationFunctions/codeutils';
+/**
+ * Sends a grep search request
+ *
+ * @param pattern - The search pattern
+ * @param filePath - Optional file path to search in
+ * @param recursive - Optional recursive search flag
+ * @param ignoreCase - Optional ignore case flag
+ * @param maxResults - Optional maximum number of results
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 4.1 - WHEN I call `codebolt.notify.codeutils.GrepSearchRequestNotify()` THEN the system SHALL send a GrepSearchRequestNotification via WebSocket
+ */
+export declare function GrepSearchRequestNotify(pattern: string, filePath?: string, recursive?: boolean, ignoreCase?: boolean, maxResults?: number, toolUseId?: string): void;
+/**
+ * Sends a response to a grep search request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data with matches and totalMatches
+ *
+ * Requirements: 4.2 - WHEN I call `codebolt.notify.codeutils.GrepSearchResponseNotify()` THEN the system SHALL send a GrepSearchResponseNotification via WebSocket
+ */
+export declare function GrepSearchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: GrepSearchResponseNotification['data']): void;
+/**
+ * Sends a glob search request
+ *
+ * @param pattern - The glob pattern
+ * @param basePath - Optional base path to search in
+ * @param maxDepth - Optional maximum search depth
+ * @param includeDirectories - Optional flag to include directories
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 4.3 - WHEN I call `codebolt.notify.codeutils.GlobSearchRequestNotify()` THEN the system SHALL send a GlobSearchRequestNotification via WebSocket
+ */
+export declare function GlobSearchRequestNotify(pattern: string, basePath?: string, maxDepth?: number, includeDirectories?: boolean, toolUseId?: string): void;
+/**
+ * Sends a response to a glob search request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data with files and totalFiles
+ *
+ * Requirements: 4.4 - WHEN I call `codebolt.notify.codeutils.GlobSearchResponseNotify()` THEN the system SHALL send a GlobSearchResponseNotification via WebSocket
+ */
+export declare function GlobSearchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: GlobSearchResponseNotification['data']): void;
+/**
+ * Codeutils notification functions object
+ */
+export declare const codeutilsNotifications: CodeutilsNotifications;
+export default codeutilsNotifications;

package/dist/notificationfunctions/codeutils.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Code Utils Notification Functions
+ *
+ * This module provides functions for sending code utilities-related notifications,
+ * including grep search and glob search operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeutilsNotifications = exports.GlobSearchResponseNotify = exports.GlobSearchRequestNotify = exports.GrepSearchResponseNotify = exports.GrepSearchRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a grep search request
+ *
+ * @param pattern - The search pattern
+ * @param filePath - Optional file path to search in
+ * @param recursive - Optional recursive search flag
+ * @param ignoreCase - Optional ignore case flag
+ * @param maxResults - Optional maximum number of results
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 4.1 - WHEN I call `codebolt.notify.codeutils.GrepSearchRequestNotify()` THEN the system SHALL send a GrepSearchRequestNotification via WebSocket
+ */
+function GrepSearchRequestNotify(pattern, filePath, recursive, ignoreCase, maxResults, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ pattern }, ['pattern'], 'codeutils.GrepSearchRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "codeutilsnotify",
+        action: "grepSearchRequest",
+        data: {
+            pattern: pattern,
+            filePath: filePath,
+            recursive: recursive,
+            ignoreCase: ignoreCase,
+            maxResults: maxResults
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'codeutils.GrepSearchRequestNotify');
+}
+exports.GrepSearchRequestNotify = GrepSearchRequestNotify;
+/**
+ * Sends a response to a grep search request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data with matches and totalMatches
+ *
+ * Requirements: 4.2 - WHEN I call `codebolt.notify.codeutils.GrepSearchResponseNotify()` THEN the system SHALL send a GrepSearchResponseNotification via WebSocket
+ */
+function GrepSearchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for codeutils.GrepSearchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "codeutilsnotify",
+        action: "grepSearchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'codeutils.GrepSearchResponseNotify');
+}
+exports.GrepSearchResponseNotify = GrepSearchResponseNotify;
+/**
+ * Sends a glob search request
+ *
+ * @param pattern - The glob pattern
+ * @param basePath - Optional base path to search in
+ * @param maxDepth - Optional maximum search depth
+ * @param includeDirectories - Optional flag to include directories
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 4.3 - WHEN I call `codebolt.notify.codeutils.GlobSearchRequestNotify()` THEN the system SHALL send a GlobSearchRequestNotification via WebSocket
+ */
+function GlobSearchRequestNotify(pattern, basePath, maxDepth, includeDirectories, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ pattern }, ['pattern'], 'codeutils.GlobSearchRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "codeutilsnotify",
+        action: "globSearchRequest",
+        data: {
+            pattern: pattern,
+            basePath: basePath,
+            maxDepth: maxDepth,
+            includeDirectories: includeDirectories
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'codeutils.GlobSearchRequestNotify');
+}
+exports.GlobSearchRequestNotify = GlobSearchRequestNotify;
+/**
+ * Sends a response to a glob search request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data with files and totalFiles
+ *
+ * Requirements: 4.4 - WHEN I call `codebolt.notify.codeutils.GlobSearchResponseNotify()` THEN the system SHALL send a GlobSearchResponseNotification via WebSocket
+ */
+function GlobSearchResponseNotify(content, isError = false, toolUseId, data) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for codeutils.GlobSearchResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "codeutilsnotify",
+        action: "globSearchResult",
+        content: content,
+        isError: isError,
+        data: data
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'codeutils.GlobSearchResponseNotify');
+}
+exports.GlobSearchResponseNotify = GlobSearchResponseNotify;
+/**
+ * Codeutils notification functions object
+ */
+exports.codeutilsNotifications = {
+    GrepSearchRequestNotify,
+    GrepSearchResponseNotify,
+    GlobSearchRequestNotify,
+    GlobSearchResponseNotify
+};
+// Default export
+exports.default = exports.codeutilsNotifications;

package/dist/notificationfunctions/crawler.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Crawler Notification Functions
+ *
+ * This module provides functions for sending crawler-related notifications,
+ * including web crawling search operations and crawler initialization.
+ */
+import { CrawlerSearchResponseNotification, CrawlerStartResponseNotification } from '../types/notifications/crawler';
+import { CrawlerNotifications } from '../types/notificationFunctions/crawler';
+/**
+ * Sends a request to perform a crawler search
+ *
+ * @param url - The URL to crawl
+ * @param searchQuery - Optional search query
+ * @param maxDepth - Optional maximum crawl depth
+ * @param maxPages - Optional maximum pages to crawl
+ * @param includeSubdomains - Optional flag to include subdomains
+ * @param followRedirects - Optional flag to follow redirects
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 5.1 - WHEN I call `codebolt.notify.crawler.CrawlerSearchRequestNotify()` THEN the system SHALL send a CrawlerSearchRequestNotification via WebSocket
+ */
+export declare function CrawlerSearchRequestNotify(url: string, searchQuery?: string, maxDepth?: number, maxPages?: number, includeSubdomains?: boolean, followRedirects?: boolean, toolUseId?: string): void;
+/**
+ * Sends a response to a crawler search request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data containing pages, totalPages, and crawlTime
+ *
+ * Requirements: 5.2 - WHEN I call `codebolt.notify.crawler.CrawlerSearchResponseNotify()` THEN the system SHALL send a CrawlerSearchResponseNotification via WebSocket
+ */
+export declare function CrawlerSearchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: CrawlerSearchResponseNotification['data']): void;
+/**
+ * Sends a request to start a crawler
+ *
+ * @param startUrl - The URL to start crawling from
+ * @param options - Optional crawler configuration options
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 5.3 - WHEN I call `codebolt.notify.crawler.CrawlerStartRequestNotify()` THEN the system SHALL send a CrawlerStartRequestNotification via WebSocket
+ */
+export declare function CrawlerStartRequestNotify(startUrl: string, options?: any, toolUseId?: string): void;
+/**
+ * Sends a response to a crawler start request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ * @param data - Optional response data containing sessionId and status
+ *
+ * Requirements: 5.4 - WHEN I call `codebolt.notify.crawler.CrawlerStartResponseNotify()` THEN the system SHALL send a CrawlerStartResponseNotification via WebSocket
+ */
+export declare function CrawlerStartResponseNotify(content: string | any, isError?: boolean, toolUseId?: string, data?: CrawlerStartResponseNotification['data']): void;
+/**
+ * Crawler notification functions object
+ */
+export declare const crawlerNotifications: CrawlerNotifications;
+export default crawlerNotifications;