@codebolt/codeboltjs 2.0.12 → 2.0.15

package/dist/notificationfunctions/fs.js

@@ -0,0 +1,472 @@
+"use strict";
+/**
+ * File System Notification Functions
+ *
+ * This module provides functions for sending file system-related notifications,
+ * including file and folder operations like create, read, edit, delete, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsNotifications = exports.MoveFileResponseNotify = exports.MoveFileRequestNotify = exports.CopyFileResponseNotify = exports.CopyFileRequestNotify = exports.AppendToFileResponseNotify = exports.AppendToFileRequestNotify = exports.WriteToFileResponseNotify = exports.WriteToFileRequestNotify = exports.ListDirectoryResponseNotify = exports.ListDirectoryRequestNotify = exports.FolderDeleteResponseNotify = exports.FolderDeleteRequestNotify = exports.FileDeleteResponseNotify = exports.FileDeleteRequestNotify = exports.FileEditResponseNotify = exports.FileEditRequestNotify = exports.FileReadResponseNotify = exports.FileReadRequestNotify = exports.FolderCreateResponseNotify = exports.FolderCreateRequestNotify = exports.FileCreateResponseNotify = exports.FileCreateRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a request to create a file
+ * Requirements: 7.1
+ */
+function FileCreateRequestNotify(fileName, source, filePath, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ fileName, source, filePath }, ['fileName', 'source', 'filePath'], 'fs.FileCreateRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "createFileRequest",
+        data: {
+            fileName: fileName,
+            source: source,
+            filePath: filePath
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FileCreateRequestNotify');
+}
+exports.FileCreateRequestNotify = FileCreateRequestNotify;
+/**
+ * Sends a response to a file creation request
+ * Requirements: 7.2
+ */
+function FileCreateResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.FileCreateResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "createFileResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FileCreateResponseNotify');
+}
+exports.FileCreateResponseNotify = FileCreateResponseNotify;
+/**
+ * Sends a request to create a folder
+ * Requirements: 7.3
+ */
+function FolderCreateRequestNotify(folderName, folderPath, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ folderName, folderPath }, ['folderName', 'folderPath'], 'fs.FolderCreateRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "createFolderRequest",
+        data: {
+            folderName: folderName,
+            folderPath: folderPath
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FolderCreateRequestNotify');
+}
+exports.FolderCreateRequestNotify = FolderCreateRequestNotify;
+/**
+ * Sends a response to a folder creation request
+ * Requirements: 7.4
+ */
+function FolderCreateResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.FolderCreateResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "createFolderResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FolderCreateResponseNotify');
+}
+exports.FolderCreateResponseNotify = FolderCreateResponseNotify;
+/**
+ * Sends a request to read a file
+ * Requirements: 7.4
+ */
+function FileReadRequestNotify(filePath, startLine, endLine, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ filePath }, ['filePath'], 'fs.FileReadRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "readFileRequest",
+        data: {
+            filePath: filePath,
+            startLine: startLine,
+            endLine: endLine
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FileReadRequestNotify');
+}
+exports.FileReadRequestNotify = FileReadRequestNotify;
+/**
+ * Sends a response to a file read request
+ * Requirements: 7.4
+ */
+function FileReadResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.FileReadResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "readFileResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FileReadResponseNotify');
+}
+exports.FileReadResponseNotify = FileReadResponseNotify;
+/**
+ * Sends a request to edit a file
+ * Requirements: 7.5
+ */
+function FileEditRequestNotify(fileName, filePath, newContent, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ fileName, filePath, newContent }, ['fileName', 'filePath', 'newContent'], 'fs.FileEditRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "updateFileRequest",
+        data: {
+            fileName: fileName,
+            filePath: filePath,
+            newContent: newContent
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FileEditRequestNotify');
+}
+exports.FileEditRequestNotify = FileEditRequestNotify;
+/**
+ * Sends a response to a file edit request
+ * Requirements: 7.5
+ */
+function FileEditResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.FileEditResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "updateFileResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FileEditResponseNotify');
+}
+exports.FileEditResponseNotify = FileEditResponseNotify;
+/**
+ * Sends a request to delete a file
+ * Requirements: 7.6
+ */
+function FileDeleteRequestNotify(fileName, filePath, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ fileName, filePath }, ['fileName', 'filePath'], 'fs.FileDeleteRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "deleteFileRequest",
+        data: {
+            fileName: fileName,
+            filePath: filePath
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FileDeleteRequestNotify');
+}
+exports.FileDeleteRequestNotify = FileDeleteRequestNotify;
+/**
+ * Sends a response to a file delete request
+ * Requirements: 7.6
+ */
+function FileDeleteResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.FileDeleteResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "deleteFileResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FileDeleteResponseNotify');
+}
+exports.FileDeleteResponseNotify = FileDeleteResponseNotify;
+/**
+ * Sends a request to delete a folder
+ * Requirements: 7.6
+ */
+function FolderDeleteRequestNotify(folderName, folderPath, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ folderName, folderPath }, ['folderName', 'folderPath'], 'fs.FolderDeleteRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "deleteFolderRequest",
+        data: {
+            folderName: folderName,
+            folderPath: folderPath
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FolderDeleteRequestNotify');
+}
+exports.FolderDeleteRequestNotify = FolderDeleteRequestNotify;
+/**
+ * Sends a response to a folder delete request
+ * Requirements: 7.6
+ */
+function FolderDeleteResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.FolderDeleteResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "deleteFolderResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.FolderDeleteResponseNotify');
+} /**
+ *
+Sends a request to list directory contents
+ * Requirements: 7.7
+ */
+exports.FolderDeleteResponseNotify = FolderDeleteResponseNotify;
+function ListDirectoryRequestNotify(dirPath, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ dirPath }, ['dirPath'], 'fs.ListDirectoryRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "listDirectoryRequest",
+        data: {
+            dirPath: dirPath
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.ListDirectoryRequestNotify');
+}
+exports.ListDirectoryRequestNotify = ListDirectoryRequestNotify;
+/**
+ * Sends a response to a directory listing request
+ * Requirements: 7.7
+ */
+function ListDirectoryResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.ListDirectoryResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "listDirectoryResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.ListDirectoryResponseNotify');
+}
+exports.ListDirectoryResponseNotify = ListDirectoryResponseNotify;
+/**
+ * Sends a request to write to a file
+ * Requirements: 7.8
+ */
+function WriteToFileRequestNotify(filePath, text, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ filePath, text }, ['filePath', 'text'], 'fs.WriteToFileRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "writeToFileRequest",
+        data: {
+            filePath: filePath,
+            text: text
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.WriteToFileRequestNotify');
+}
+exports.WriteToFileRequestNotify = WriteToFileRequestNotify;
+/**
+ * Sends a response to a write to file request
+ * Requirements: 7.8
+ */
+function WriteToFileResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.WriteToFileResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "writeToFileResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.WriteToFileResponseNotify');
+}
+exports.WriteToFileResponseNotify = WriteToFileResponseNotify;
+/**
+ * Sends a request to append to a file
+ * Requirements: 7.9
+ */
+function AppendToFileRequestNotify(filePath, text, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ filePath, text }, ['filePath', 'text'], 'fs.AppendToFileRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "appendToFileRequest",
+        data: {
+            filePath: filePath,
+            text: text
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.AppendToFileRequestNotify');
+}
+exports.AppendToFileRequestNotify = AppendToFileRequestNotify;
+/**
+ * Sends a response to an append to file request
+ * Requirements: 7.9
+ */
+function AppendToFileResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.AppendToFileResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "appendToFileResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.AppendToFileResponseNotify');
+} /**
+
+ * Sends a request to copy a file
+ * Requirements: 7.10
+ */
+exports.AppendToFileResponseNotify = AppendToFileResponseNotify;
+function CopyFileRequestNotify(sourceFile, destinationFile, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ sourceFile, destinationFile }, ['sourceFile', 'destinationFile'], 'fs.CopyFileRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "copyFileRequest",
+        data: {
+            sourceFile: sourceFile,
+            destinationFile: destinationFile
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.CopyFileRequestNotify');
+}
+exports.CopyFileRequestNotify = CopyFileRequestNotify;
+/**
+ * Sends a response to a file copy request
+ * Requirements: 7.10
+ */
+function CopyFileResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.CopyFileResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "copyFileResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.CopyFileResponseNotify');
+}
+exports.CopyFileResponseNotify = CopyFileResponseNotify;
+/**
+ * Sends a request to move a file
+ * Requirements: 7.11
+ */
+function MoveFileRequestNotify(sourceFile, destinationFile, toolUseId) {
+    if (!(0, utils_1.validateRequiredFields)({ sourceFile, destinationFile }, ['sourceFile', 'destinationFile'], 'fs.MoveFileRequestNotify')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "moveFileRequest",
+        data: {
+            sourceFile: sourceFile,
+            destinationFile: destinationFile
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.MoveFileRequestNotify');
+}
+exports.MoveFileRequestNotify = MoveFileRequestNotify;
+/**
+ * Sends a response to a file move request
+ * Requirements: 7.11
+ */
+function MoveFileResponseNotify(content, isError = false, toolUseId) {
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for fs.MoveFileResponseNotify');
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "fsnotify",
+        action: "moveFileResult",
+        content: content,
+        isError: isError
+    };
+    (0, utils_1.sendNotification)(notification, 'fs.MoveFileResponseNotify');
+}
+exports.MoveFileResponseNotify = MoveFileResponseNotify;
+/**
+ * File system notification functions object
+ */
+exports.fsNotifications = {
+    FileCreateRequestNotify,
+    FileCreateResponseNotify,
+    FolderCreateRequestNotify,
+    FolderCreateResponseNotify,
+    FileReadRequestNotify,
+    FileReadResponseNotify,
+    FileEditRequestNotify,
+    FileEditResponseNotify,
+    FileDeleteRequestNotify,
+    FileDeleteResponseNotify,
+    FolderDeleteRequestNotify,
+    FolderDeleteResponseNotify,
+    ListDirectoryRequestNotify,
+    ListDirectoryResponseNotify,
+    WriteToFileRequestNotify,
+    WriteToFileResponseNotify,
+    AppendToFileRequestNotify,
+    AppendToFileResponseNotify,
+    CopyFileRequestNotify,
+    CopyFileResponseNotify,
+    MoveFileRequestNotify,
+    MoveFileResponseNotify
+};
+/**
+ * Default export
+ */
+exports.default = exports.fsNotifications;

package/dist/notificationfunctions/git.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Git Notification Functions
+ *
+ * This module provides functions for sending git-related notifications,
+ * including version control operations.
+ */
+import { GitNotifications } from '../types/notificationFunctions/git';
+/**
+ * Sends a git init request notification
+ * @param path - Optional path where to initialize the git repository
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitInitRequestNotify(path?: string, toolUseId?: string): void;
+/**
+ * Sends a git init response notification
+ * @param content - The response content (success message or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitInitResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git pull request notification
+ * @param path - Optional path where to perform the git pull
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitPullRequestNotify(path?: string, toolUseId?: string): void;
+/**
+ * Sends a git pull response notification
+ * @param content - The response content (success message or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitPullResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git push request notification
+ * @param path - Optional path where to perform the git push
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitPushRequestNotify(path?: string, toolUseId?: string): void;
+/**
+ * Sends a git push response notification
+ * @param content - The response content (success message or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitPushResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git status request notification
+ * @param path - Optional path where to check git status
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitStatusRequestNotify(path?: string, toolUseId?: string): void;
+/**
+ * Sends a git status response notification
+ * @param content - The response content (status information or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitStatusResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git add request notification
+ * @param path - Optional path where to perform git add
+ * @param files - Optional array of files to add
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitAddRequestNotify(path?: string, files?: string[], toolUseId?: string): void;
+/**
+ * Sends a git add response notification
+ * @param content - The response content (success message or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitAddResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git commit request notification
+ * @param path - Optional path where to perform git commit
+ * @param message - Optional commit message
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitCommitRequestNotify(path?: string, message?: string, toolUseId?: string): void;
+/**
+ * Sends a git commit response notification
+ * @param content - The response content (commit information or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitCommitResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git checkout request notification
+ * @param path - Optional path where to perform git checkout
+ * @param branchName - Optional branch name to checkout
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitCheckoutRequestNotify(path?: string, branchName?: string, toolUseId?: string): void;
+/**
+ * Sends a git checkout response notification
+ * @param content - The response content (checkout information or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitCheckoutResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git branch request notification
+ * @param path - Optional path where to perform git branch operation
+ * @param branchName - Optional branch name to create or list
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitBranchRequestNotify(path?: string, branchName?: string, toolUseId?: string): void;
+/**
+ * Sends a git branch response notification
+ * @param content - The response content (branch information or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitBranchResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git logs request notification
+ * @param path - Optional path where to get git logs
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitLogsRequestNotify(path?: string, toolUseId?: string): void;
+/**
+ * Sends a git logs response notification
+ * @param content - The response content (log information or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitLogsResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git diff request notification
+ * @param path - Optional path where to get git diff
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitDiffRequestNotify(path?: string, toolUseId?: string): void;
+/**
+ * Sends a git diff response notification
+ * @param content - The response content (diff information or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitDiffResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git remote add request notification
+ * @param remoteName - Name of the remote to add
+ * @param remoteUrl - URL of the remote repository
+ * @param path - Optional path where to add the remote
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitRemoteAddRequestNotify(remoteName: string, remoteUrl: string, path?: string, toolUseId?: string): void;
+/**
+ * Sends a git remote add response notification
+ * @param content - The response content (success message or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitRemoteAddResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a git clone request notification
+ * @param repoUrl - URL of the repository to clone
+ * @param targetPath - Optional target path for the cloned repository
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GitCloneRequestNotify(repoUrl: string, targetPath?: string, toolUseId?: string): void;
+/**
+ * Sends a git clone response notification
+ * @param content - The response content (clone information or error details)
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GitCloneResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Git notification functions object
+ */
+export declare const gitNotifications: GitNotifications;