@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/modules/codemap.js

@@ -0,0 +1,100 @@
+"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");
+/**
+ * Codemap Module for codeboltjs
+ * Provides functionality for managing codemaps (visual representations of code structure).
+ * Mirrors the codemapService.cli.ts operations via WebSocket.
+ */
+const codeboltCodemap = {
+    /**
+     * List all codemaps for a project
+     */
+    list: async (projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codemapEvent',
+            action: 'codemap.list',
+            requestId,
+            message: { projectPath }
+        }, 'codemapListResponse');
+    },
+    /**
+     * Get a specific codemap by ID
+     */
+    get: async (codemapId, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codemapEvent',
+            action: 'codemap.get',
+            requestId,
+            message: { codemapId, projectPath }
+        }, 'codemapGetResponse');
+    },
+    /**
+     * Create a placeholder codemap (status: 'creating')
+     * Call this before generating the actual codemap content
+     */
+    create: async (data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codemapEvent',
+            action: 'codemap.create',
+            requestId,
+            message: { ...data, projectPath }
+        }, 'codemapCreateResponse');
+    },
+    /**
+     * Save a complete codemap with content
+     */
+    save: async (codemapId, codemap, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codemapEvent',
+            action: 'codemap.save',
+            requestId,
+            message: { codemapId, codemap, projectPath }
+        }, 'codemapSaveResponse');
+    },
+    /**
+     * Set the status of a codemap
+     */
+    setStatus: async (codemapId, status, error, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codemapEvent',
+            action: 'codemap.setStatus',
+            requestId,
+            message: { codemapId, status, error, projectPath }
+        }, 'codemapSetStatusResponse');
+    },
+    /**
+     * Update codemap info (title, description, etc.)
+     */
+    update: async (codemapId, data, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codemapEvent',
+            action: 'codemap.update',
+            requestId,
+            message: { codemapId, ...data, projectPath }
+        }, 'codemapUpdateResponse');
+    },
+    /**
+     * Delete a codemap
+     */
+    delete: async (codemapId, projectPath) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'codemapEvent',
+            action: 'codemap.delete',
+            requestId,
+            message: { codemapId, projectPath }
+        }, 'codemapDeleteResponse');
+    }
+};
+exports.default = codeboltCodemap;

package/dist/modules/contextAssembly.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Context Assembly Module
+ * Provides context assembly engine operations for building agent context
+ */
+import type { ContextAssemblyResponse, ContextValidateResponse, MemoryTypesResponse, RuleEvaluationResponse, RequiredVariablesResponse, ContextAssemblyRequest } from '../types/contextAssembly';
+declare const contextAssembly: {
+    /**
+     * Assemble context from various memory sources
+     * @param request - Context assembly request
+     */
+    getContext: (request: ContextAssemblyRequest) => Promise<ContextAssemblyResponse>;
+    /**
+     * Validate a context assembly request
+     * @param request - Request to validate
+     */
+    validate: (request: ContextAssemblyRequest) => Promise<ContextValidateResponse>;
+    /**
+     * List available memory types
+     */
+    listMemoryTypes: () => Promise<MemoryTypesResponse>;
+    /**
+     * Evaluate rules only without fetching memory content
+     * @param request - Context assembly request
+     * @param ruleEngineIds - Optional specific rule engine IDs to evaluate
+     */
+    evaluateRules: (request: ContextAssemblyRequest, ruleEngineIds?: string[]) => Promise<RuleEvaluationResponse>;
+    /**
+     * Get required variables for specific memory types
+     * @param memoryNames - Array of memory type names
+     */
+    getRequiredVariables: (memoryNames: string[]) => Promise<RequiredVariablesResponse>;
+};
+export default contextAssembly;

package/dist/modules/contextAssembly.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Context Assembly Module
+ * Provides context assembly engine operations for building agent context
+ */
+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 contextAssembly = {
+    /**
+     * Assemble context from various memory sources
+     * @param request - Context assembly request
+     */
+    getContext: async (request) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextAssembly.getContext',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: request
+        }, 'contextAssembly.getContext');
+    },
+    /**
+     * Validate a context assembly request
+     * @param request - Request to validate
+     */
+    validate: async (request) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextAssembly.validate',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: request
+        }, 'contextAssembly.validate');
+    },
+    /**
+     * List available memory types
+     */
+    listMemoryTypes: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextAssembly.listMemoryTypes',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: {}
+        }, 'contextAssembly.listMemoryTypes');
+    },
+    /**
+     * Evaluate rules only without fetching memory content
+     * @param request - Context assembly request
+     * @param ruleEngineIds - Optional specific rule engine IDs to evaluate
+     */
+    evaluateRules: async (request, ruleEngineIds) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextAssembly.evaluateRules',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { ...request, rule_engine_ids: ruleEngineIds }
+        }, 'contextAssembly.evaluateRules');
+    },
+    /**
+     * Get required variables for specific memory types
+     * @param memoryNames - Array of memory type names
+     */
+    getRequiredVariables: async (memoryNames) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextAssembly.getRequiredVariables',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { memory_names: memoryNames }
+        }, 'contextAssembly.getRequiredVariables');
+    }
+};
+exports.default = contextAssembly;

package/dist/modules/contextRuleEngine.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Context Rule Engine Module
+ * Provides context rule engine operations for conditional memory inclusion
+ */
+import type { ContextRuleEngineResponse, ContextRuleEngineListResponse, ContextRuleEngineDeleteResponse, EvaluateRulesResponse, PossibleVariablesResponse, CreateContextRuleEngineParams, UpdateContextRuleEngineParams, EvaluateRulesParams } from '../types/contextRuleEngine';
+declare const contextRuleEngine: {
+    /**
+     * Create a new rule engine
+     * @param config - Rule engine configuration
+     */
+    create: (config: CreateContextRuleEngineParams) => Promise<ContextRuleEngineResponse>;
+    /**
+     * Get a rule engine by ID
+     * @param id - Rule engine ID
+     */
+    get: (id: string) => Promise<ContextRuleEngineResponse>;
+    /**
+     * List all rule engines
+     */
+    list: () => Promise<ContextRuleEngineListResponse>;
+    /**
+     * Update a rule engine
+     * @param id - Rule engine ID
+     * @param updates - Update parameters
+     */
+    update: (id: string, updates: UpdateContextRuleEngineParams) => Promise<ContextRuleEngineResponse>;
+    /**
+     * Delete a rule engine
+     * @param id - Rule engine ID
+     */
+    delete: (id: string) => Promise<ContextRuleEngineDeleteResponse>;
+    /**
+     * Evaluate rules against provided variables
+     * @param params - Evaluation parameters
+     */
+    evaluate: (params: EvaluateRulesParams) => Promise<EvaluateRulesResponse>;
+    /**
+     * Get all possible variables for UI configuration
+     */
+    getPossibleVariables: () => Promise<PossibleVariablesResponse>;
+};
+export default contextRuleEngine;

package/dist/modules/contextRuleEngine.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Context Rule Engine Module
+ * Provides context rule engine operations for conditional memory inclusion
+ */
+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 contextRuleEngine = {
+    /**
+     * Create a new rule engine
+     * @param config - Rule engine configuration
+     */
+    create: async (config) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextRuleEngine.create',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: config
+        }, 'contextRuleEngine.create');
+    },
+    /**
+     * Get a rule engine by ID
+     * @param id - Rule engine ID
+     */
+    get: async (id) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextRuleEngine.get',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { id }
+        }, 'contextRuleEngine.get');
+    },
+    /**
+     * List all rule engines
+     */
+    list: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextRuleEngine.list',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: {}
+        }, 'contextRuleEngine.list');
+    },
+    /**
+     * Update a rule engine
+     * @param id - Rule engine ID
+     * @param updates - Update parameters
+     */
+    update: async (id, updates) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextRuleEngine.update',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { id, ...updates }
+        }, 'contextRuleEngine.update');
+    },
+    /**
+     * Delete a rule engine
+     * @param id - Rule engine ID
+     */
+    delete: async (id) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextRuleEngine.delete',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: { id }
+        }, 'contextRuleEngine.delete');
+    },
+    /**
+     * Evaluate rules against provided variables
+     * @param params - Evaluation parameters
+     */
+    evaluate: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextRuleEngine.evaluate',
+            requestId: (0, crypto_1.randomUUID)(),
+            params
+        }, 'contextRuleEngine.evaluate');
+    },
+    /**
+     * Get all possible variables for UI configuration
+     */
+    getPossibleVariables: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'contextRuleEngine.getPossibleVariables',
+            requestId: (0, crypto_1.randomUUID)(),
+            params: {}
+        }, 'contextRuleEngine.getPossibleVariables');
+    }
+};
+exports.default = contextRuleEngine;

package/dist/modules/episodicMemory.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Episodic event stored in memory
+ */
+export interface EpisodicEvent {
+    id: string;
+    event_type: string;
+    emitting_agent_id: string;
+    team_id?: string;
+    tags?: string[];
+    payload: string | Record<string, any>;
+    timestamp: string;
+}
+/**
+ * Episodic memory container
+ */
+export interface EpisodicMemory {
+    id: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    archived: boolean;
+    eventCount: number;
+}
+/**
+ * Filter criteria for querying events
+ */
+export interface EpisodicEventFilter {
+    lastMinutes?: number;
+    lastCount?: number;
+    tags?: string[];
+    event_type?: string;
+    emitting_agent_id?: string;
+    team_id?: string;
+    since?: string;
+}
+export interface ICreateMemoryParams {
+    title: string;
+}
+export interface IGetMemoryParams {
+    memoryId?: string;
+    swarmId?: string;
+}
+export interface IAppendEventParams {
+    memoryId?: string;
+    swarmId?: string;
+    event_type: string;
+    emitting_agent_id: string;
+    team_id?: string;
+    tags?: string[];
+    payload: string | Record<string, any>;
+}
+export interface IQueryEventsParams {
+    memoryId?: string;
+    swarmId?: string;
+    lastMinutes?: number;
+    lastCount?: number;
+    tags?: string[];
+    event_type?: string;
+    emitting_agent_id?: string;
+    team_id?: string;
+    since?: string;
+}
+export interface IGetEventTypesParams {
+    memoryId?: string;
+    swarmId?: string;
+}
+export interface IGetTagsParams {
+    memoryId?: string;
+    swarmId?: string;
+}
+export interface IGetAgentsParams {
+    memoryId?: string;
+    swarmId?: string;
+}
+export interface IArchiveMemoryParams {
+    memoryId?: string;
+    swarmId?: string;
+}
+export interface IUnarchiveMemoryParams {
+    memoryId?: string;
+    swarmId?: string;
+}
+export interface IUpdateTitleParams {
+    memoryId?: string;
+    swarmId?: string;
+    title: string;
+}
+export interface EpisodicMemoryResponse {
+    success: boolean;
+    requestId?: string;
+    data?: any;
+    error?: {
+        code: string;
+        message: string;
+        details?: any;
+    };
+}
+export interface ICreateMemoryResponse extends EpisodicMemoryResponse {
+    data?: EpisodicMemory;
+}
+export interface IListMemoriesResponse extends EpisodicMemoryResponse {
+    data?: EpisodicMemory[];
+}
+export interface IGetMemoryResponse extends EpisodicMemoryResponse {
+    data?: EpisodicMemory;
+}
+export interface IAppendEventResponse extends EpisodicMemoryResponse {
+    data?: EpisodicEvent;
+}
+export interface IQueryEventsResponse extends EpisodicMemoryResponse {
+    data?: {
+        events: EpisodicEvent[];
+        total: number;
+        filtered: boolean;
+    };
+}
+export interface IGetEventTypesResponse extends EpisodicMemoryResponse {
+    data?: string[];
+}
+export interface IGetTagsResponse extends EpisodicMemoryResponse {
+    data?: string[];
+}
+export interface IGetAgentsResponse extends EpisodicMemoryResponse {
+    data?: string[];
+}
+export interface IArchiveMemoryResponse extends EpisodicMemoryResponse {
+    data?: {
+        message: string;
+    };
+}
+export interface IUnarchiveMemoryResponse extends EpisodicMemoryResponse {
+    data?: {
+        message: string;
+    };
+}
+export interface IUpdateTitleResponse extends EpisodicMemoryResponse {
+    data?: {
+        message: string;
+    };
+}
+declare const cbepisodicMemory: {
+    /**
+     * Create a new episodic memory
+     * @param params - Memory creation parameters (title)
+     * @returns Promise resolving to the created memory
+     */
+    createMemory: (params: ICreateMemoryParams) => Promise<ICreateMemoryResponse>;
+    /**
+     * List all episodic memories
+     * @returns Promise resolving to list of memories
+     */
+    listMemories: () => Promise<IListMemoriesResponse>;
+    /**
+     * Get a specific episodic memory by ID
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to the memory
+     */
+    getMemory: (params: IGetMemoryParams) => Promise<IGetMemoryResponse>;
+    /**
+     * Append an event to an episodic memory
+     * @param params - Event parameters including memoryId, event_type, emitting_agent_id, and payload
+     * @returns Promise resolving to the created event
+     */
+    appendEvent: (params: IAppendEventParams) => Promise<IAppendEventResponse>;
+    /**
+     * Query events from an episodic memory with optional filters
+     * @param params - Query parameters including memoryId and optional filters
+     * @returns Promise resolving to filtered events
+     */
+    queryEvents: (params: IQueryEventsParams) => Promise<IQueryEventsResponse>;
+    /**
+     * Get unique event types from an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to list of unique event types
+     */
+    getEventTypes: (params: IGetEventTypesParams) => Promise<IGetEventTypesResponse>;
+    /**
+     * Get unique tags from an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to list of unique tags
+     */
+    getTags: (params: IGetTagsParams) => Promise<IGetTagsResponse>;
+    /**
+     * Get unique agent IDs from an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to list of unique agent IDs
+     */
+    getAgents: (params: IGetAgentsParams) => Promise<IGetAgentsResponse>;
+    /**
+     * Archive an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to archive confirmation
+     */
+    archiveMemory: (params: IArchiveMemoryParams) => Promise<IArchiveMemoryResponse>;
+    /**
+     * Unarchive an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to unarchive confirmation
+     */
+    unarchiveMemory: (params: IUnarchiveMemoryParams) => Promise<IUnarchiveMemoryResponse>;
+    /**
+     * Update the title of an episodic memory
+     * @param params - Parameters including memoryId and new title
+     * @returns Promise resolving to update confirmation
+     */
+    updateTitle: (params: IUpdateTitleParams) => Promise<IUpdateTitleResponse>;
+};
+export default cbepisodicMemory;

package/dist/modules/episodicMemory.js

@@ -0,0 +1,131 @@
+"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"));
+// ================================
+// Episodic Memory Module
+// ================================
+const cbepisodicMemory = {
+    /**
+     * Create a new episodic memory
+     * @param params - Memory creation parameters (title)
+     * @returns Promise resolving to the created memory
+     */
+    createMemory: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.createMemory',
+            ...params
+        }, 'episodicMemory.createMemory.response');
+    },
+    /**
+     * List all episodic memories
+     * @returns Promise resolving to list of memories
+     */
+    listMemories: async () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.listMemories'
+        }, 'episodicMemory.listMemories.response');
+    },
+    /**
+     * Get a specific episodic memory by ID
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to the memory
+     */
+    getMemory: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.getMemory',
+            ...params
+        }, 'episodicMemory.getMemory.response');
+    },
+    /**
+     * Append an event to an episodic memory
+     * @param params - Event parameters including memoryId, event_type, emitting_agent_id, and payload
+     * @returns Promise resolving to the created event
+     */
+    appendEvent: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.appendEvent',
+            ...params
+        }, 'episodicMemory.appendEvent.response');
+    },
+    /**
+     * Query events from an episodic memory with optional filters
+     * @param params - Query parameters including memoryId and optional filters
+     * @returns Promise resolving to filtered events
+     */
+    queryEvents: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.queryEvents',
+            ...params
+        }, 'episodicMemory.queryEvents.response');
+    },
+    /**
+     * Get unique event types from an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to list of unique event types
+     */
+    getEventTypes: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.getEventTypes',
+            ...params
+        }, 'episodicMemory.getEventTypes.response');
+    },
+    /**
+     * Get unique tags from an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to list of unique tags
+     */
+    getTags: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.getTags',
+            ...params
+        }, 'episodicMemory.getTags.response');
+    },
+    /**
+     * Get unique agent IDs from an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to list of unique agent IDs
+     */
+    getAgents: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.getAgents',
+            ...params
+        }, 'episodicMemory.getAgents.response');
+    },
+    /**
+     * Archive an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to archive confirmation
+     */
+    archiveMemory: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.archiveMemory',
+            ...params
+        }, 'episodicMemory.archiveMemory.response');
+    },
+    /**
+     * Unarchive an episodic memory
+     * @param params - Parameters including memoryId
+     * @returns Promise resolving to unarchive confirmation
+     */
+    unarchiveMemory: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.unarchiveMemory',
+            ...params
+        }, 'episodicMemory.unarchiveMemory.response');
+    },
+    /**
+     * Update the title of an episodic memory
+     * @param params - Parameters including memoryId and new title
+     * @returns Promise resolving to update confirmation
+     */
+    updateTitle: async (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            type: 'episodicMemory.updateTitle',
+            ...params
+        }, 'episodicMemory.updateTitle.response');
+    }
+};
+exports.default = cbepisodicMemory;