@codebolt/codeboltjs 2.0.12 → 2.0.15

package/dist/notificationfunctions/git.js

@@ -0,0 +1,521 @@
+"use strict";
+/**
+ * Git Notification Functions
+ *
+ * This module provides functions for sending git-related notifications,
+ * including version control operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitNotifications = exports.GitCloneResponseNotify = exports.GitCloneRequestNotify = exports.GitRemoteAddResponseNotify = exports.GitRemoteAddRequestNotify = exports.GitDiffResponseNotify = exports.GitDiffRequestNotify = exports.GitLogsResponseNotify = exports.GitLogsRequestNotify = exports.GitBranchResponseNotify = exports.GitBranchRequestNotify = exports.GitCheckoutResponseNotify = exports.GitCheckoutRequestNotify = exports.GitCommitResponseNotify = exports.GitCommitRequestNotify = exports.GitAddResponseNotify = exports.GitAddRequestNotify = exports.GitStatusResponseNotify = exports.GitStatusRequestNotify = exports.GitPushResponseNotify = exports.GitPushRequestNotify = exports.GitPullResponseNotify = exports.GitPullRequestNotify = exports.GitInitResponseNotify = exports.GitInitRequestNotify = void 0;
+const utils_1 = require("./utils");
+// ===== GIT INIT FUNCTIONS =====
+/**
+ * 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
+ */
+function GitInitRequestNotify(path, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "initRequest",
+        data: {
+            path: path
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-init');
+}
+exports.GitInitRequestNotify = GitInitRequestNotify;
+/**
+ * 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
+ */
+function GitInitResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "initResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-init-response');
+}
+exports.GitInitResponseNotify = GitInitResponseNotify;
+// ===== GIT PULL FUNCTIONS =====
+/**
+ * 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
+ */
+function GitPullRequestNotify(path, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "pullRequest",
+        data: {
+            path: path
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-pull');
+}
+exports.GitPullRequestNotify = GitPullRequestNotify;
+/**
+ * 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
+ */
+function GitPullResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "pullResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-pull-response');
+}
+exports.GitPullResponseNotify = GitPullResponseNotify;
+// ===== GIT PUSH FUNCTIONS =====
+/**
+ * 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
+ */
+function GitPushRequestNotify(path, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "pushRequest",
+        data: {
+            path: path
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-push');
+}
+exports.GitPushRequestNotify = GitPushRequestNotify;
+/**
+ * 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
+ */
+function GitPushResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "pushResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-push-response');
+}
+exports.GitPushResponseNotify = GitPushResponseNotify;
+// ===== GIT STATUS FUNCTIONS =====
+/**
+ * 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
+ */
+function GitStatusRequestNotify(path, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "statusRequest",
+        data: {
+            path: path
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-status');
+}
+exports.GitStatusRequestNotify = GitStatusRequestNotify;
+/**
+ * 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
+ */
+function GitStatusResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "statusResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-status-response');
+}
+exports.GitStatusResponseNotify = GitStatusResponseNotify;
+// ===== GIT ADD FUNCTIONS =====
+/**
+ * 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
+ */
+function GitAddRequestNotify(path, files, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "addRequest",
+        data: {
+            path: path,
+            files: files
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-add');
+}
+exports.GitAddRequestNotify = GitAddRequestNotify;
+/**
+ * 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
+ */
+function GitAddResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "addResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-add-response');
+}
+exports.GitAddResponseNotify = GitAddResponseNotify;
+// ===== GIT COMMIT FUNCTIONS =====
+/**
+ * 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
+ */
+function GitCommitRequestNotify(path, message, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "commitRequest",
+        data: {
+            path: path,
+            message: message
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-commit');
+}
+exports.GitCommitRequestNotify = GitCommitRequestNotify;
+/**
+ * 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
+ */
+function GitCommitResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "commitResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-commit-response');
+}
+exports.GitCommitResponseNotify = GitCommitResponseNotify;
+// ===== GIT CHECKOUT FUNCTIONS =====
+/**
+ * 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
+ */
+function GitCheckoutRequestNotify(path, branchName, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "checkoutRequest",
+        data: {
+            path: path,
+            branchName: branchName
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-checkout');
+}
+exports.GitCheckoutRequestNotify = GitCheckoutRequestNotify;
+/**
+ * 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
+ */
+function GitCheckoutResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "checkoutResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-checkout-response');
+}
+exports.GitCheckoutResponseNotify = GitCheckoutResponseNotify;
+// ===== GIT BRANCH FUNCTIONS =====
+/**
+ * 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
+ */
+function GitBranchRequestNotify(path, branchName, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "branchRequest",
+        data: {
+            path: path,
+            branchName: branchName
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-branch');
+}
+exports.GitBranchRequestNotify = GitBranchRequestNotify;
+/**
+ * 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
+ */
+function GitBranchResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "branchResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-branch-response');
+}
+exports.GitBranchResponseNotify = GitBranchResponseNotify;
+// ===== GIT LOGS FUNCTIONS =====
+/**
+ * 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
+ */
+function GitLogsRequestNotify(path, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "logsRequest",
+        data: {
+            path: path
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-logs');
+}
+exports.GitLogsRequestNotify = GitLogsRequestNotify;
+/**
+ * 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
+ */
+function GitLogsResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "logsResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-logs-response');
+}
+exports.GitLogsResponseNotify = GitLogsResponseNotify;
+// ===== GIT DIFF FUNCTIONS =====
+/**
+ * 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
+ */
+function GitDiffRequestNotify(path, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "diffRequest",
+        data: {
+            path: path
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-diff');
+}
+exports.GitDiffRequestNotify = GitDiffRequestNotify;
+/**
+ * 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
+ */
+function GitDiffResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "diffResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-diff-response');
+}
+exports.GitDiffResponseNotify = GitDiffResponseNotify;
+// ===== GIT REMOTE ADD FUNCTIONS =====
+/**
+ * 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
+ */
+function GitRemoteAddRequestNotify(remoteName, remoteUrl, path, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "remoteAddRequest",
+        data: {
+            path: path,
+            remoteName: remoteName,
+            remoteUrl: remoteUrl
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-remote-add');
+}
+exports.GitRemoteAddRequestNotify = GitRemoteAddRequestNotify;
+/**
+ * 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
+ */
+function GitRemoteAddResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "remoteAddResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-remote-add-response');
+}
+exports.GitRemoteAddResponseNotify = GitRemoteAddResponseNotify;
+// ===== GIT CLONE FUNCTIONS =====
+/**
+ * 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
+ */
+function GitCloneRequestNotify(repoUrl, targetPath, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "gitnotify",
+        action: "cloneRequest",
+        data: {
+            repoUrl: repoUrl,
+            targetPath: targetPath
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'git-clone');
+}
+exports.GitCloneRequestNotify = GitCloneRequestNotify;
+/**
+ * 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
+ */
+function GitCloneResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[GitNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "gitnotify",
+        action: "cloneResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'git-clone-response');
+}
+exports.GitCloneResponseNotify = GitCloneResponseNotify;
+/**
+ * Git notification functions object
+ */
+exports.gitNotifications = {
+    GitInitRequestNotify,
+    GitInitResponseNotify,
+    GitPullRequestNotify,
+    GitPullResponseNotify,
+    GitPushRequestNotify,
+    GitPushResponseNotify,
+    GitStatusRequestNotify,
+    GitStatusResponseNotify,
+    GitAddRequestNotify,
+    GitAddResponseNotify,
+    GitCommitRequestNotify,
+    GitCommitResponseNotify,
+    GitCheckoutRequestNotify,
+    GitCheckoutResponseNotify,
+    GitBranchRequestNotify,
+    GitBranchResponseNotify,
+    GitLogsRequestNotify,
+    GitLogsResponseNotify,
+    GitDiffRequestNotify,
+    GitDiffResponseNotify,
+    GitRemoteAddRequestNotify,
+    GitRemoteAddResponseNotify,
+    GitCloneRequestNotify,
+    GitCloneResponseNotify
+};

package/dist/notificationfunctions/history.d.ts

@@ -0,0 +1,38 @@
+/**
+ * History Notification Functions
+ *
+ * This module provides functions for sending history-related notifications,
+ * including conversation summarization operations.
+ */
+import { SummarizePreviousConversationRequestNotification, SummarizeCurentMessageRequestNotification } from '../types/notifications/history';
+import { HistoryNotifications } from '../types/notificationFunctions/history';
+/**
+ * Sends a summarize previous conversation request notification
+ * @param data - Optional data object (currently empty but may be extended)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function summarizePreviousConversation(data?: SummarizePreviousConversationRequestNotification['data'], toolUseId?: string): void;
+/**
+ * Sends a summarize previous conversation result notification
+ * @param content - The summarization result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function sendSummarizePreviousResult(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a summarize current message request notification
+ * @param data - Summarization data containing messages and depth
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function summarizeCurrentMessage(data: SummarizeCurentMessageRequestNotification['data'], toolUseId?: string): void;
+/**
+ * Sends a summarize current message result notification
+ * @param content - The summarization result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function sendSummarizeCurrentResult(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * History notification functions object
+ */
+export declare const historyNotifications: HistoryNotifications;

package/dist/notificationfunctions/history.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * History Notification Functions
+ *
+ * This module provides functions for sending history-related notifications,
+ * including conversation summarization operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.historyNotifications = exports.sendSummarizeCurrentResult = exports.summarizeCurrentMessage = exports.sendSummarizePreviousResult = exports.summarizePreviousConversation = void 0;
+const utils_1 = require("./utils");
+// ===== SUMMARIZE PREVIOUS CONVERSATION FUNCTIONS =====
+/**
+ * Sends a summarize previous conversation request notification
+ * @param data - Optional data object (currently empty but may be extended)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function summarizePreviousConversation(data = {}, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "historynotify",
+        action: "summarizeAllRequest",
+        data
+    };
+    (0, utils_1.sendNotification)(notification, 'history-summarize-previous');
+}
+exports.summarizePreviousConversation = summarizePreviousConversation;
+/**
+ * Sends a summarize previous conversation result notification
+ * @param content - The summarization result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function sendSummarizePreviousResult(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[HistoryNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "historynotify",
+        action: "summarizeAllResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'history-summarize-previous-result');
+}
+exports.sendSummarizePreviousResult = sendSummarizePreviousResult;
+// ===== SUMMARIZE CURRENT MESSAGE FUNCTIONS =====
+/**
+ * Sends a summarize current message request notification
+ * @param data - Summarization data containing messages and depth
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function summarizeCurrentMessage(data, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)(data, ['messages', 'depth'], 'history-summarize-current')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "historynotify",
+        action: "summarizeRequest",
+        data
+    };
+    (0, utils_1.sendNotification)(notification, 'history-summarize-current');
+}
+exports.summarizeCurrentMessage = summarizeCurrentMessage;
+/**
+ * Sends a summarize current message result notification
+ * @param content - The summarization result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function sendSummarizeCurrentResult(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[HistoryNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "historynotify",
+        action: "summarizeResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'history-summarize-current-result');
+}
+exports.sendSummarizeCurrentResult = sendSummarizeCurrentResult;
+/**
+ * History notification functions object
+ */
+exports.historyNotifications = {
+    summarizePreviousConversation,
+    sendSummarizePreviousResult,
+    summarizeCurrentMessage,
+    sendSummarizeCurrentResult
+};