@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/modules/eventLog.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Event Log Module
+ * Provides event logging operations for agent activities
+ */
+import type { EventLogInstanceResponse, EventLogInstanceListResponse, EventLogAppendResponse, EventLogAppendMultipleResponse, EventLogQueryResponse, EventLogStatsResponse, EventLogDSL, UpdateEventLogInstanceParams, AppendEventParams, AppendEventsParams } from '../types/eventLog';
+declare const eventLog: {
+    /**
+     * Create a new event log instance
+     * @param name - Instance name
+     * @param description - Optional description
+     */
+    createInstance: (name: string, description?: string) => Promise<EventLogInstanceResponse>;
+    /**
+     * Get an event log instance by ID
+     * @param instanceId - Instance ID
+     */
+    getInstance: (instanceId: string) => Promise<EventLogInstanceResponse>;
+    /**
+     * List all event log instances
+     */
+    listInstances: () => Promise<EventLogInstanceListResponse>;
+    /**
+     * Update an event log instance
+     * @param instanceId - Instance ID
+     * @param updates - Update parameters
+     */
+    updateInstance: (instanceId: string, updates: UpdateEventLogInstanceParams) => Promise<EventLogInstanceResponse>;
+    /**
+     * Delete an event log instance
+     * @param instanceId - Instance ID
+     */
+    deleteInstance: (instanceId: string) => Promise<EventLogInstanceResponse>;
+    /**
+     * Append a single event to the log
+     * @param params - Event parameters
+     */
+    appendEvent: (params: AppendEventParams) => Promise<EventLogAppendResponse>;
+    /**
+     * Append multiple events to the log
+     * @param params - Events parameters
+     */
+    appendEvents: (params: AppendEventsParams) => Promise<EventLogAppendMultipleResponse>;
+    /**
+     * Query events using DSL
+     * @param query - Query DSL object
+     */
+    queryEvents: (query: EventLogDSL) => Promise<EventLogQueryResponse>;
+    /**
+     * Get instance statistics
+     * @param instanceId - Instance ID
+     */
+    getInstanceStats: (instanceId: string) => Promise<EventLogStatsResponse>;
+};
+export default eventLog;

package/dist/modules/eventLog.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Event Log Module
+ * Provides event logging operations for agent activities
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+const crypto_1 = require("crypto");
+const eventLog = {
+    /**
+     * Create a new event log instance
+     * @param name - Instance name
+     * @param description - Optional description
+     */
+    createInstance: async (name, description) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.createInstance',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { name, description }
+        }, 'eventLog.createInstance');
+    },
+    /**
+     * Get an event log instance by ID
+     * @param instanceId - Instance ID
+     */
+    getInstance: async (instanceId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.getInstance',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { instanceId }
+        }, 'eventLog.getInstance');
+    },
+    /**
+     * List all event log instances
+     */
+    listInstances: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.listInstances',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: {}
+        }, 'eventLog.listInstances');
+    },
+    /**
+     * Update an event log instance
+     * @param instanceId - Instance ID
+     * @param updates - Update parameters
+     */
+    updateInstance: async (instanceId, updates) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.updateInstance',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { instanceId, ...updates }
+        }, 'eventLog.updateInstance');
+    },
+    /**
+     * Delete an event log instance
+     * @param instanceId - Instance ID
+     */
+    deleteInstance: async (instanceId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.deleteInstance',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { instanceId }
+        }, 'eventLog.deleteInstance');
+    },
+    /**
+     * Append a single event to the log
+     * @param params - Event parameters
+     */
+    appendEvent: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.appendEvent',
+            requestId: (0, crypto_1.randomUUID)(),
+            params
+        }, 'eventLog.appendEvent');
+    },
+    /**
+     * Append multiple events to the log
+     * @param params - Events parameters
+     */
+    appendEvents: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.appendEvents',
+            requestId: (0, crypto_1.randomUUID)(),
+            params
+        }, 'eventLog.appendEvents');
+    },
+    /**
+     * Query events using DSL
+     * @param query - Query DSL object
+     */
+    queryEvents: async (query) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.queryEvents',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { query }
+        }, 'eventLog.queryEvents');
+    },
+    /**
+     * Get instance statistics
+     * @param instanceId - Instance ID
+     */
+    getInstanceStats: async (instanceId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'eventLog.getInstanceStats',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { instanceId }
+        }, 'eventLog.getInstanceStats');
+    }
+};
+exports.default = eventLog;

package/dist/modules/fileUpdateIntent.d.ts

@@ -0,0 +1,58 @@
+import type { CreateFileUpdateIntentRequest, UpdateFileUpdateIntentRequest, FileUpdateIntentFilters, FileUpdateIntent, IntentOverlapResult, FileWithIntent } from '../types/fileUpdateIntent';
+/**
+ * File Update Intent service client for codeboltjs.
+ */
+declare const fileUpdateIntentService: {
+    /**
+     * Create a new file update intent
+     */
+    create: (data: CreateFileUpdateIntentRequest, claimedBy: string, claimedByName?: string) => Promise<{
+        intent?: FileUpdateIntent;
+        overlap?: IntentOverlapResult;
+    }>;
+    /**
+     * Update an existing intent
+     */
+    update: (id: string, data: UpdateFileUpdateIntentRequest) => Promise<FileUpdateIntent>;
+    /**
+     * Get a single intent
+     */
+    get: (id: string) => Promise<FileUpdateIntent>;
+    /**
+     * List intents
+     */
+    list: (filters?: FileUpdateIntentFilters) => Promise<FileUpdateIntent[]>;
+    /**
+     * Complete an intent
+     */
+    complete: (id: string, closedBy: string) => Promise<FileUpdateIntent>;
+    /**
+     * Cancel an intent
+     */
+    cancel: (id: string, cancelledBy: string) => Promise<FileUpdateIntent>;
+    /**
+     * Check for overlap without creating
+     */
+    checkOverlap: (environmentId: string, filePaths: string[], priority?: number) => Promise<IntentOverlapResult>;
+    /**
+     * Get blocked files (level 4 locks)
+     */
+    getBlockedFiles: (environmentId: string) => Promise<{
+        blockedFiles: string[];
+    }>;
+    /**
+     * Get intents by agent
+     */
+    getByAgent: (agentId: string) => Promise<FileUpdateIntent[]>;
+    /**
+     * Get all files with intents
+     */
+    getFilesWithIntents: (environmentId: string) => Promise<FileWithIntent[]>;
+    /**
+     * Delete an intent
+     */
+    delete: (id: string) => Promise<{
+        success: boolean;
+    }>;
+};
+export default fileUpdateIntentService;

package/dist/modules/fileUpdateIntent.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+const crypto_1 = require("crypto");
+/**
+ * File Update Intent service client for codeboltjs.
+ */
+const fileUpdateIntentService = {
+    /**
+     * Create a new file update intent
+     */
+    create: async (data, claimedBy, claimedByName) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.create',
+            action: 'create',
+            requestId,
+            message: { ...data, claimedBy, claimedByName }
+        }, 'fileUpdateIntent.create');
+    },
+    /**
+     * Update an existing intent
+     */
+    update: async (id, data) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.update',
+            action: 'update',
+            requestId,
+            message: { id, ...data }
+        }, 'fileUpdateIntent.update');
+    },
+    /**
+     * Get a single intent
+     */
+    get: async (id) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.get',
+            action: 'get',
+            requestId,
+            message: { id }
+        }, 'fileUpdateIntent.get');
+    },
+    /**
+     * List intents
+     */
+    list: async (filters = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.list',
+            action: 'list',
+            requestId,
+            message: filters
+        }, 'fileUpdateIntent.list');
+    },
+    /**
+     * Complete an intent
+     */
+    complete: async (id, closedBy) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.complete',
+            action: 'complete',
+            requestId,
+            message: { id, closedBy }
+        }, 'fileUpdateIntent.complete');
+    },
+    /**
+     * Cancel an intent
+     */
+    cancel: async (id, cancelledBy) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.cancel',
+            action: 'cancel',
+            requestId,
+            message: { id, cancelledBy }
+        }, 'fileUpdateIntent.cancel');
+    },
+    /**
+     * Check for overlap without creating
+     */
+    checkOverlap: async (environmentId, filePaths, priority = 5) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.checkOverlap',
+            action: 'checkOverlap',
+            requestId,
+            message: { environmentId, filePaths, priority }
+        }, 'fileUpdateIntent.checkOverlap');
+    },
+    /**
+     * Get blocked files (level 4 locks)
+     */
+    getBlockedFiles: async (environmentId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.getBlockedFiles',
+            action: 'getBlockedFiles',
+            requestId,
+            message: { environmentId }
+        }, 'fileUpdateIntent.getBlockedFiles');
+    },
+    /**
+     * Get intents by agent
+     */
+    getByAgent: async (agentId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.getByAgent',
+            action: 'getByAgent',
+            requestId,
+            message: { agentId }
+        }, 'fileUpdateIntent.getByAgent');
+    },
+    /**
+     * Get all files with intents
+     */
+    getFilesWithIntents: async (environmentId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.getFilesWithIntents',
+            action: 'getFilesWithIntents',
+            requestId,
+            message: { environmentId }
+        }, 'fileUpdateIntent.getFilesWithIntents');
+    },
+    /**
+     * Delete an intent
+     */
+    delete: async (id) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'fileUpdateIntent.delete',
+            action: 'delete',
+            requestId,
+            message: { id }
+        }, 'fileUpdateIntent.delete');
+    }
+};
+exports.default = fileUpdateIntentService;

package/dist/modules/fs.js

@@ -19,13 +19,24 @@ const cbfs = {
      * @returns {Promise<CreateFileResponse>} A promise that resolves with the server response.
      */
     createFile: (fileName, source, filePath) => {
+        // Construct full path if filePath is a directory, or handle as is if it looks like a path
+        // Since write-file tool sends dirPath as filePath, we should try to join. 
+        // However, we don't have 'path' module easily here without importing it? 
+        // This is a node module, so we can likely import path or use simple string concat if we assume separator.
+        // Let's use a safe join approach or just template string if we are sure of environment.
+        // Since this is codeboltjs which runs in node (usually), we can try to use delimiters.
+        // But to be safe and simple: let's assume filePath is the DIRECTORY as per usages.
+        let fullPath = filePath;
+        if (fileName) {
+            const separator = filePath.includes('\\') ? '\\' : '/';
+            fullPath = filePath.endsWith(separator) ? `${filePath}${fileName}` : `${filePath}${separator}${fileName}`;
+        }
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.FS_EVENT,
             "action": enum_1.FSAction.CREATE_FILE,
             "message": {
-                fileName,
-                source,
-                filePath
+                filePath: fullPath,
+                content: source
             },
         }, enum_1.FSResponseType.CREATE_FILE_RESPONSE);
     },
@@ -37,12 +48,17 @@ const cbfs = {
      * @returns {Promise<CreateFolderResponse>} A promise that resolves with the server response.
      */
     createFolder: (folderName, folderPath) => {
+        // Similar logic for folder
+        let fullPath = folderPath;
+        if (folderName) {
+            const separator = folderPath.includes('\\') ? '\\' : '/';
+            fullPath = folderPath.endsWith(separator) ? `${folderPath}${folderName}` : `${folderPath}${separator}${folderName}`;
+        }
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.FS_EVENT,
             "action": enum_1.FSAction.CREATE_FOLDER,
             "message": {
-                folderName,
-                folderPath
+                path: fullPath
             },
         }, enum_1.FSResponseType.CREATE_FOLDER_RESPONSE);
     },
@@ -75,9 +91,8 @@ const cbfs = {
             "type": enum_1.EventType.FS_EVENT,
             "action": enum_1.FSAction.UPDATE_FILE,
             "message": {
-                filename,
-                filePath,
-                newContent
+                path: filePath, // Server expects 'path'
+                content: newContent // Server expects 'content'
             },
         }, enum_1.FSResponseType.UPDATE_FILE_RESPONSE);
     },
@@ -123,12 +138,14 @@ const cbfs = {
     listFile: (folderPath, isRecursive = false) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.FS_EVENT,
-            "action": enum_1.FSAction.FILE_LIST,
-            message: {
-                folderPath,
-                isRecursive
+            "action": "listFiles",
+            "message": {
+                path: folderPath,
+                options: {
+                    recursive: isRecursive
+                }
             }
-        }, enum_1.FSResponseType.FILE_LIST_RESPONSE);
+        }, "listFilesResponse");
     },
     /**
      * @function listCodeDefinitionNames
@@ -139,7 +156,7 @@ const cbfs = {
     listCodeDefinitionNames: (path) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.FS_EVENT,
-            "action": enum_1.FSAction.LIST_CODE_DEFINITION_NAMES,
+            "action": "listCodeDefinitions",
             "message": {
                 path
             }
@@ -202,13 +219,15 @@ const cbfs = {
     grepSearch: (path, query, includePattern, excludePattern, caseSensitive = true) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.FS_EVENT,
-            "action": enum_1.FSAction.GREP_SEARCH,
+            "action": "grepSearch",
             "message": {
                 path,
-                query,
-                includePattern,
-                excludePattern,
-                caseSensitive
+                pattern: query,
+                options: {
+                    includePattern,
+                    excludePattern,
+                    caseSensitive
+                }
             }
         }, enum_1.FSResponseType.GREP_SEARCH_RESPONSE);
     },
@@ -221,11 +240,11 @@ const cbfs = {
     fileSearch: (query) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.FS_EVENT,
-            "action": enum_1.FSAction.FILE_SEARCH,
+            "action": "fuzzySearch",
             "message": {
                 query
             }
-        }, enum_1.FSResponseType.FILE_SEARCH_RESPONSE);
+        }, "fuzzySearchResponse");
     },
     /**
      * @function editFileWithDiff
@@ -240,13 +259,15 @@ const cbfs = {
     editFileWithDiff: (targetFile, codeEdit, diffIdentifier, prompt, applyModel) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.FS_EVENT,
-            "action": enum_1.FSAction.EDIT_FILE_WITH_DIFF,
+            "action": "applyDiff",
             "message": {
-                target_file: targetFile,
-                code_edit: codeEdit,
-                diffIdentifier,
-                prompt,
-                applyModel
+                path: targetFile,
+                diff: codeEdit,
+                options: {
+                    diffIdentifier,
+                    prompt,
+                    applyModel
+                }
             }
         }, enum_1.FSResponseType.EDIT_FILE_AND_APPLY_DIFF_RESPONSE);
     },
@@ -268,7 +289,7 @@ const cbfs = {
     readManyFiles: (params) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.FS_EVENT,
-            "action": enum_1.FSAction.READ_MANY_FILES,
+            "action": "readManyFiles",
             "message": params
         }, enum_1.FSResponseType.READ_MANY_FILES_RESPONSE);
     },

package/dist/modules/git.d.ts

@@ -1,4 +1,4 @@
-import { GitInitResponse, GitPullResponse, GitPushResponse, GitStatusResponse, AddResponse, GitCommitResponse, GitCheckoutResponse, GitBranchResponse, GitLogsResponse, GitDiffResponse } from '@codebolt/types/sdk';
+import { GitInitResponse, GitPullResponse, GitPushResponse, GitStatusResponse, AddResponse, GitCommitResponse, GitCheckoutResponse, GitBranchResponse, GitLogsResponse, GitDiffResponse, GitCloneResponse } from '@codebolt/types/sdk';
 /**
  * A service for interacting with Git operations via WebSocket messages.
  */
@@ -66,5 +66,12 @@ declare const gitService: {
      * @returns {Promise<GitDiffResponse>} A promise that resolves with the response from the diff event.
      */
     diff: (commitHash: string) => Promise<GitDiffResponse>;
+    /**
+     * Clones a remote Git repository to the specified path.
+     * @param {string} url - The URL of the remote repository to clone.
+     * @param {string} path - The file system path where the repository should be cloned.
+     * @returns {Promise<GitCloneResponse>} A promise that resolves with the response from the clone event.
+     */
+    clone: (url: string, path?: string) => Promise<GitCloneResponse>;
 };
 export default gitService;

package/dist/modules/git.js

@@ -127,6 +127,20 @@ const gitService = {
             "action": enum_1.GitAction.DIFF,
             "commitHash": commitHash
         }, enum_1.GitResponseType.DIFF_RESPONSE);
+    },
+    /**
+     * Clones a remote Git repository to the specified path.
+     * @param {string} url - The URL of the remote repository to clone.
+     * @param {string} path - The file system path where the repository should be cloned.
+     * @returns {Promise<GitCloneResponse>} A promise that resolves with the response from the clone event.
+     */
+    clone: async (url, path) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.GIT_EVENT,
+            "action": enum_1.GitAction.CLONE,
+            "url": url,
+            "path": path
+        }, enum_1.GitResponseType.CLONE_RESPONSE);
     }
 };
 exports.default = gitService;

package/dist/modules/groupFeedback.d.ts

@@ -0,0 +1,11 @@
+import { ICreateFeedbackParams, ICreateFeedbackResponse, IGetFeedbackParams, IGetFeedbackResponse, IListFeedbacksParams, IListFeedbacksResponse, IRespondParams, IRespondResponse, IReplyParams, IReplyResponse, IUpdateSummaryParams, IUpdateSummaryResponse, IUpdateStatusParams, IUpdateStatusResponse } from '../types/groupFeedback';
+declare const cbgroupFeedback: {
+    create: (params: ICreateFeedbackParams) => Promise<ICreateFeedbackResponse>;
+    get: (params: IGetFeedbackParams) => Promise<IGetFeedbackResponse>;
+    list: (params?: IListFeedbacksParams) => Promise<IListFeedbacksResponse>;
+    respond: (params: IRespondParams) => Promise<IRespondResponse>;
+    reply: (params: IReplyParams) => Promise<IReplyResponse>;
+    updateSummary: (params: IUpdateSummaryParams) => Promise<IUpdateSummaryResponse>;
+    updateStatus: (params: IUpdateStatusParams) => Promise<IUpdateStatusResponse>;
+};
+export default cbgroupFeedback;

package/dist/modules/groupFeedback.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+const groupFeedback_1 = require("../types/groupFeedback");
+const cbgroupFeedback = {
+    create: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ type: groupFeedback_1.GroupFeedbackAction.CREATE, ...params }, groupFeedback_1.GroupFeedbackResponseType.CREATE_RESPONSE);
+    },
+    get: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ type: groupFeedback_1.GroupFeedbackAction.GET, ...params }, groupFeedback_1.GroupFeedbackResponseType.GET_RESPONSE);
+    },
+    list: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ type: groupFeedback_1.GroupFeedbackAction.LIST, ...(params || {}) }, groupFeedback_1.GroupFeedbackResponseType.LIST_RESPONSE);
+    },
+    respond: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ type: groupFeedback_1.GroupFeedbackAction.RESPOND, ...params }, groupFeedback_1.GroupFeedbackResponseType.RESPOND_RESPONSE);
+    },
+    reply: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ type: groupFeedback_1.GroupFeedbackAction.REPLY, ...params }, groupFeedback_1.GroupFeedbackResponseType.REPLY_RESPONSE);
+    },
+    updateSummary: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ type: groupFeedback_1.GroupFeedbackAction.SUMMARY, ...params }, groupFeedback_1.GroupFeedbackResponseType.SUMMARY_RESPONSE);
+    },
+    updateStatus: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ type: groupFeedback_1.GroupFeedbackAction.UPDATE_STATUS, ...params }, groupFeedback_1.GroupFeedbackResponseType.UPDATE_STATUS_RESPONSE);
+    },
+};
+exports.default = cbgroupFeedback;

package/dist/modules/hook.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Hook Module
+ * Provides hook management for triggering actions
+ */
+import type { HookResponse, HookListResponse, HookInitializeResponse, HookDeleteResponse, HookConfig } from '../types/hook';
+declare const hook: {
+    /**
+     * Initialize the hook manager for a project
+     * @param projectPath - Path to the project
+     */
+    initialize: (projectPath: string) => Promise<HookInitializeResponse>;
+    /**
+     * Create a new hook
+     * @param config - Hook configuration
+     */
+    create: (config: HookConfig) => Promise<HookResponse>;
+    /**
+     * Update an existing hook
+     * @param hookId - Hook ID
+     * @param config - Updated hook configuration
+     */
+    update: (hookId: string, config: Partial<HookConfig>) => Promise<HookResponse>;
+    /**
+     * Delete a hook
+     * @param hookId - Hook ID
+     */
+    delete: (hookId: string) => Promise<HookDeleteResponse>;
+    /**
+     * List all hooks
+     */
+    list: () => Promise<HookListResponse>;
+    /**
+     * Get a hook by ID
+     * @param hookId - Hook ID
+     */
+    get: (hookId: string) => Promise<HookResponse>;
+    /**
+     * Enable a hook
+     * @param hookId - Hook ID
+     */
+    enable: (hookId: string) => Promise<HookResponse>;
+    /**
+     * Disable a hook
+     * @param hookId - Hook ID
+     */
+    disable: (hookId: string) => Promise<HookResponse>;
+};
+export default hook;