@codebolt/codeboltjs 2.0.6 → 2.0.11

package/dist/agentlib/promptbuilder.js

@@ -0,0 +1,487 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptBuilder = void 0;
+const systemprompt_1 = require("./systemprompt");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// All interfaces moved to appropriate type files
+/**
+ * PromptBuilder class for constructing prompts using a fluent interface.
+ * Allows chaining methods to build complex prompts from user messages.
+ */
+class PromptBuilder {
+    /**
+     * Creates a new PromptBuilder instance.
+     *
+     * @param userMessage - The initial user message containing text and mentioned entities
+     * @param codebolt - Optional codebolt API instance for automatic tool and environment loading
+     */
+    constructor(userMessage, codebolt) {
+        var _a;
+        /** System prompt text */
+        this.systemPromptText = "";
+        /** Task instruction text */
+        this.taskInstructionText = "";
+        /** Available tools */
+        this.tools = [];
+        /** Conversation history */
+        this.conversationHistory = [];
+        /** Environment details */
+        this.environmentDetails = "";
+        /** File contents cache */
+        this.fileContents = new Map();
+        // Handle both InitialUserMessage and CLIUserMessage types
+        if ('message' in userMessage && typeof userMessage.message === 'object') {
+            // This is a CLIUserMessage with nested message structure
+            this.message = userMessage.message.userMessage || ((_a = userMessage.data) === null || _a === void 0 ? void 0 : _a.text) || "";
+            this.mentionedFiles = userMessage.message.mentionedFiles || [];
+            // Convert string array to MCPTool array for CLIUserMessage
+            this.mentionedMCPs = (userMessage.message.mentionedMCPs || []).map((name) => ({ name }));
+            this.mentionedAgents = userMessage.message.mentionedAgents || [];
+        }
+        else {
+            // This is an InitialUserMessage
+            this.message = userMessage.messageText || userMessage.userMessage || "";
+            this.mentionedFiles = userMessage.mentionedFiles || [];
+            this.mentionedMCPs = userMessage.mentionedMCPs || [];
+            this.mentionedAgents = userMessage.mentionedAgents || [];
+        }
+        this.promptParts = [this.message];
+        this.codebolt = codebolt;
+    }
+    /**
+     * Sets the codebolt API instance for automatic operations.
+     *
+     * @param codebolt - The codebolt API instance
+     * @returns The PromptBuilder instance for chaining
+     */
+    setCodeboltAPI(codebolt) {
+        this.codebolt = codebolt;
+        return this;
+    }
+    /**
+     * Automatically loads and adds MCP tools from the mentioned MCPs in the user message.
+     * Also loads default codebolt tools.
+     *
+     * @param additionalServers - Additional MCP servers to load tools from
+     * @returns The PromptBuilder instance for chaining
+     */
+    async addMCPTools(additionalServers = ["codebolt"]) {
+        if (!this.codebolt) {
+            console.warn("Codebolt API not available. Cannot load MCP tools automatically.");
+            return this;
+        }
+        try {
+            // Get default tools from specified servers
+            const { data: defaultTools } = await this.codebolt.mcp.listMcpFromServers(additionalServers);
+            this.tools = [...this.tools, ...defaultTools];
+            // Get tools from mentioned MCPs
+            if (this.mentionedMCPs && this.mentionedMCPs.length > 0) {
+                const { data: mcpTools } = await this.codebolt.mcp.getTools(this.mentionedMCPs);
+                this.tools = [...this.tools, ...mcpTools];
+            }
+        }
+        catch (error) {
+            console.error(`Error loading MCP tools: ${error}`);
+        }
+        return this;
+    }
+    /**
+     * Automatically converts mentioned agents to OpenAI tool format and adds them.
+     *
+     * @returns The PromptBuilder instance for chaining
+     */
+    addAgentTools() {
+        if (this.mentionedAgents && this.mentionedAgents.length > 0) {
+            const agentTools = this.mentionedAgents.map(agent => ({
+                type: "function",
+                function: {
+                    name: `subagent--${agent.unique_id}`,
+                    description: agent.longDescription || agent.description || "Agent tool",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            task: {
+                                type: "string",
+                                description: "The task to be executed by the tool."
+                            }
+                        },
+                        required: ["task"]
+                    }
+                }
+            }));
+            this.tools = [...this.tools, ...agentTools];
+        }
+        return this;
+    }
+    /**
+     * Automatically loads file contents for mentioned files and adds environment details.
+     *
+     * @returns The PromptBuilder instance for chaining
+     */
+    async addEnvironmentDetails() {
+        if (!this.codebolt) {
+            console.warn("Codebolt API not available. Cannot load environment details automatically.");
+            return this;
+        }
+        try {
+            // Load mentioned file contents
+            if (this.mentionedFiles && this.mentionedFiles.length > 0) {
+                for (const file of this.mentionedFiles) {
+                    try {
+                        const fileData = await this.codebolt.fs.readFile(file);
+                        this.fileContents.set(file, fileData);
+                    }
+                    catch (error) {
+                        console.error(`Error reading file ${file}: ${error}`);
+                        this.fileContents.set(file, "[File could not be read]");
+                    }
+                }
+            }
+            // Get project path and file listing
+            const { projectPath } = await this.codebolt.project.getProjectPath();
+            if (projectPath) {
+                const { success, result } = await this.codebolt.fs.listFile(projectPath, true);
+                if (success) {
+                    this.environmentDetails = `\n\n<environment_details>\n\n# Current Working Directory (${projectPath}) Files\n${result}\n</environment_details>`;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error loading environment details: ${error}`);
+        }
+        return this;
+    }
+    /**
+     * Convenience method to automatically add all tools and environment details.
+     * Equivalent to calling addMCPTools(), addAgentTools(), and addEnvironmentDetails().
+     *
+     * @param additionalServers - Additional MCP servers to load tools from
+     * @returns The PromptBuilder instance for chaining
+     */
+    async addAllAutomatic(additionalServers = ["codebolt"]) {
+        await this.addMCPTools(additionalServers);
+        this.addAgentTools();
+        await this.addEnvironmentDetails();
+        return this;
+    }
+    /**
+     * Adds system prompt from a YAML file.
+     *
+     * @param filepath - Path to the YAML file containing system prompts
+     * @param key - Key identifier for the specific prompt
+     * @param exampleFilePath - Optional path to example file to append
+     * @returns The PromptBuilder instance for chaining
+     */
+    addSystemPrompt(filepath, key, exampleFilePath) {
+        try {
+            const systemPrompt = new systemprompt_1.SystemPrompt(filepath, key);
+            this.systemPromptText = systemPrompt.toPromptText();
+            // Add example file if provided
+            if (exampleFilePath) {
+                try {
+                    const example = fs_1.default.readFileSync(path_1.default.resolve(exampleFilePath), 'utf8');
+                    this.systemPromptText += `\n\n<example_agent>\n\n${example}\n</example_agent>`;
+                }
+                catch (error) {
+                    console.error(`Error loading example file: ${error}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error loading system prompt: ${error}`);
+        }
+        return this;
+    }
+    /**
+     * Adds task instruction from a YAML file.
+     *
+     * @param filepath - Path to the YAML file containing task instructions
+     * @param refsection - Section name within the YAML file
+     * @returns The PromptBuilder instance for chaining
+     */
+    addTaskInstruction(filepath, refsection) {
+        try {
+            const fileContents = fs_1.default.readFileSync(path_1.default.resolve(filepath), 'utf8');
+            const data = js_yaml_1.default.load(fileContents);
+            const task = data[refsection];
+            if (task) {
+                this.taskInstructionText = `Task Description: ${task.description}\nExpected Output: ${task.expected_output}`;
+            }
+        }
+        catch (error) {
+            console.error(`Error loading task instruction: ${error}`);
+        }
+        return this;
+    }
+    /**
+     * Manually adds environment details with file listing.
+     * Use addEnvironmentDetails() for automatic loading instead.
+     *
+     * @param projectPath - The project path
+     * @param fileListResult - The file listing result
+     * @returns The PromptBuilder instance for chaining
+     */
+    setEnvironmentDetails(projectPath, fileListResult) {
+        if (projectPath && fileListResult) {
+            this.environmentDetails = `\n\n<environment_details>\n\n# Current Working Directory (${projectPath}) Files\n${fileListResult}\n</environment_details>`;
+        }
+        return this;
+    }
+    /**
+     * Adds MCP tools information to the prompt.
+     * Only adds content if there are mentioned MCPs.
+     *
+     * @returns The PromptBuilder instance for chaining
+     */
+    addMCPToolsToPrompt() {
+        if (this.mentionedMCPs.length > 0) {
+            const mcpTools = this.mentionedMCPs.map(mcp => {
+                const name = mcp.name || mcp.toolbox || "Unknown";
+                const toolName = mcp.toolName || "";
+                const tools = mcp.tools ? JSON.stringify(mcp.tools) : "[]";
+                let mcpInfo = `MCP: ${name}`;
+                if (toolName) {
+                    mcpInfo += `, Tool: ${toolName}`;
+                }
+                mcpInfo += `, Tools: ${tools}`;
+                return mcpInfo;
+            }).join("\n");
+            this.promptParts.push(`[MCP Tools]\n${mcpTools}`);
+        }
+        return this;
+    }
+    /**
+     * Adds agent information to the prompt.
+     * Only adds content if there are mentioned agents.
+     *
+     * @returns The PromptBuilder instance for chaining
+     */
+    addAgentsToPrompt() {
+        if (this.mentionedAgents.length > 0) {
+            const agentList = this.mentionedAgents.map(agent => {
+                const identifier = agent.name || agent.title || agent.id || agent.agent_id || "Unknown";
+                let agentInfo = `Agent: ${identifier}`;
+                if (agent.description) {
+                    agentInfo += ` - ${agent.description}`;
+                }
+                return agentInfo;
+            }).join("\n");
+            this.promptParts.push(`[Agents]\n${agentList}`);
+        }
+        return this;
+    }
+    /**
+     * Manually sets the available tools for the conversation.
+     * Use addMCPTools() and addAgentTools() for automatic loading instead.
+     *
+     * @param tools - Array of OpenAI tools
+     * @returns The PromptBuilder instance for chaining
+     */
+    setTools(tools) {
+        this.tools = [...tools];
+        return this;
+    }
+    /**
+     * Adds additional tools to the existing tool list.
+     *
+     * @param tools - Array of OpenAI tools to add
+     * @returns The PromptBuilder instance for chaining
+     */
+    addTools(tools) {
+        this.tools = [...this.tools, ...tools];
+        return this;
+    }
+    /**
+     * Builds the user message content with files and environment details.
+     *
+     * @returns Array of content blocks
+     */
+    buildUserMessageContent() {
+        let finalPrompt = `
+                    The user has sent the following query:
+                   <user_query> ${this.message} </user_query>.
+                `;
+        // Attach files if mentioned
+        if (this.mentionedFiles && this.mentionedFiles.length > 0) {
+            finalPrompt += `The Attached files are:`;
+            for (const file of this.mentionedFiles) {
+                const fileData = this.fileContents.get(file) || "[File content not available]";
+                finalPrompt += `File Name: ${file}, File Path: ${file}, Filedata: ${fileData}`;
+            }
+        }
+        // Add environment details
+        if (this.environmentDetails) {
+            finalPrompt += this.environmentDetails;
+        }
+        const content = [
+            { type: "text", text: finalPrompt }
+        ];
+        // Add task instruction if available
+        if (this.taskInstructionText) {
+            content.push({
+                type: "text",
+                text: this.taskInstructionText
+            });
+        }
+        return content;
+    }
+    /**
+     * Builds the OpenAI conversation format.
+     *
+     * @returns Array of OpenAI messages
+     */
+    buildOpenAIMessages() {
+        const messages = [];
+        // Add system message if available
+        if (this.systemPromptText) {
+            messages.push({
+                role: "system",
+                content: this.systemPromptText
+            });
+        }
+        // Add user message
+        const userContent = this.buildUserMessageContent();
+        messages.push({
+            role: "user",
+            content: userContent
+        });
+        // Add any existing conversation history
+        messages.push(...this.conversationHistory);
+        return messages;
+    }
+    /**
+     * Gets the available tools in OpenAI format.
+     *
+     * @returns Array of OpenAI tools
+     */
+    getTools() {
+        return this.tools;
+    }
+    /**
+     * Gets the loaded file contents.
+     *
+     * @returns Map of file paths to their contents
+     */
+    getFileContents() {
+        return new Map(this.fileContents);
+    }
+    /**
+     * Adds a message to the conversation history.
+     *
+     * @param role - The role of the message sender
+     * @param content - The content of the message
+     * @param toolCallId - Optional tool call ID for tool messages
+     * @param toolCalls - Optional tool calls for assistant messages
+     * @returns The PromptBuilder instance for chaining
+     */
+    addToConversationHistory(role, content, toolCallId, toolCalls) {
+        const message = { role, content };
+        if (toolCallId) {
+            message.tool_call_id = toolCallId;
+        }
+        if (toolCalls) {
+            message.tool_calls = toolCalls;
+        }
+        this.conversationHistory.push(message);
+        return this;
+    }
+    /**
+     * Gets the current conversation history.
+     *
+     * @returns Array of conversation entries
+     */
+    getConversationHistory() {
+        return [...this.conversationHistory];
+    }
+    /**
+     * Adds a custom text section to the prompt.
+     *
+     * @param title - Optional title for the section
+     * @param content - The content to add
+     * @returns The PromptBuilder instance for chaining
+     */
+    addCustomSection(title, content) {
+        if (content.trim()) {
+            const section = title ? `[${title}]\n${content}` : content;
+            this.promptParts.push(section);
+        }
+        return this;
+    }
+    /**
+     * Adds a system instruction to the prompt.
+     *
+     * @param instruction - The system instruction to add
+     * @returns The PromptBuilder instance for chaining
+     */
+    addSystemInstruction(instruction) {
+        if (instruction.trim()) {
+            this.promptParts.push(`[System Instruction]\n${instruction}`);
+        }
+        return this;
+    }
+    /**
+     * Adds context information to the prompt.
+     *
+     * @param context - The context information to add
+     * @returns The PromptBuilder instance for chaining
+     */
+    addContext(context) {
+        if (context.trim()) {
+            this.promptParts.push(`[Context]\n${context}`);
+        }
+        return this;
+    }
+    /**
+     * Builds and returns the final prompt string.
+     * Joins all prompt parts with double newlines.
+     *
+     * @returns The complete prompt string
+     */
+    build() {
+        return this.promptParts.join("\n\n");
+    }
+    /**
+     * Gets the current prompt parts without building the final string.
+     * Useful for debugging or inspection.
+     *
+     * @returns Array of current prompt parts
+     */
+    getPromptParts() {
+        return [...this.promptParts];
+    }
+    /**
+     * Clears all prompt parts except the initial message.
+     * Useful for starting over with the same message.
+     *
+     * @returns The PromptBuilder instance for chaining
+     */
+    reset() {
+        this.promptParts = [this.message];
+        this.conversationHistory = [];
+        this.systemPromptText = "";
+        this.taskInstructionText = "";
+        this.tools = [];
+        this.environmentDetails = "";
+        this.fileContents.clear();
+        return this;
+    }
+    /**
+     * Creates an LLM inference parameters object in the format expected by the sample code.
+     *
+     * @returns Object with messages, tools, and other LLM parameters
+     */
+    buildInferenceParams() {
+        return {
+            full: true,
+            messages: this.buildOpenAIMessages(),
+            tools: this.getTools(),
+            tool_choice: "auto",
+        };
+    }
+}
+exports.PromptBuilder = PromptBuilder;

package/dist/agentlib/taskInstruction.d.ts

@@ -1,28 +1,6 @@
-import { UserMessage, UserMessageContent } from "./usermessage";
-/**
- * Interface for tools that can be used within tasks.
- * Each tool has a description and usage example.
- */
-interface Tools {
-    [key: string]: {
-        /** Description of what the tool does */
-        description: string;
-        /** How to use the tool correctly */
-        usage: string;
-        /** Optional example demonstrating tool usage */
-        example?: string;
-    };
-}
-/**
- * Interface for user message structure.
- * Contains message type and text content.
- */
-interface UserMessages {
-    /** The type of user message */
-    type: string;
-    /** The text content of the message */
-    text: string;
-}
+import { UserMessage } from "./usermessage";
+import type { UserMessageContent } from "../types/libFunctionTypes";
+import type { Tools, UserMessages } from "../types/InternalTypes";
 /**
  * Class representing a task instruction.
  * Handles loading task data and converting it to prompts.

package/dist/agentlib/usermessage.d.ts

@@ -1,42 +1,6 @@
-/**
- * Interface representing an agent that can be referenced in user messages.
- */
-interface agent {
-    /** Short description of the agent */
-    description: string;
-    /** Title/name of the agent */
-    title: string;
-    /** Numeric ID of the agent */
-    id: number;
-    /** Agent identifier string */
-    agent_id: string;
-    /** Unique identifier for the agent */
-    unique_id: string;
-    /** Detailed description of the agent and its capabilities */
-    longDescription: string;
-}
-/**
- * Interface for the user message structure.
- */
-interface Message {
-    /** The actual text content of the user message */
-    userMessage: string;
-    /** Optional list of files mentioned in the message */
-    mentionedFiles?: string[];
-    /** List of MCP (Model Context Protocol) tools mentioned */
-    mentionedMCPs: string[];
-    /** List of agents mentioned in the message */
-    mentionedAgents: agent[];
-}
-/**
- * Interface for a single content block within a user message.
- */
-export interface UserMessageContent {
-    /** Type of content (e.g., "text", "image") */
-    type: string;
-    /** The text content */
-    text: string;
-}
+import type { UserMessageContent } from "../types/libFunctionTypes";
+import type { Agent } from "../types/commonTypes";
+import type { Message } from "../types/InternalTypes";
 /**
  * Class that processes and manages user messages.
  * Handles converting messages to prompts and extracting mentioned entities.
@@ -49,7 +13,10 @@ declare class UserMessage {
     /** Array of content blocks for the user message */
     userMessages: UserMessageContent[];
     /** List of MCP tools mentioned in the message */
-    mentionedMCPs: string[];
+    mentionedMCPs: {
+        toolbox: string;
+        toolName: string;
+    }[];
     /**
      * Creates a new UserMessage instance.
      *
@@ -76,19 +43,22 @@ declare class UserMessage {
      *
      * @returns Array of agent objects
      */
-    getMentionedAgents(): agent[];
+    getMentionedAgents(): Agent[];
     /**
      * Gets MCP tools mentioned in the message.
      *
      * @returns Array of MCP tool names
      */
-    getMentionedMcps(): string[];
+    getMentionedMcps(): {
+        toolbox: string;
+        toolName: string;
+    }[];
     /**
      * Gets MCP tools in a format suitable for the LLM.
      *
      * @returns Promise with an array of MCP tools
      */
-    getMentionedMcpsTools(): Promise<any>;
+    getMentionedMcpsTools(): Promise<any[] | undefined>;
     /**
      * Gets environment details for the current working directory.
      *

package/dist/agentlib/usermessage.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserMessage = void 0;
 const fs_1 = __importDefault(require("../modules/fs"));
 const project_1 = __importDefault(require("../modules/project"));
-const tools_1 = __importDefault(require("../modules/tools"));
+const mcp_1 = __importDefault(require("../modules/mcp"));
+// All interfaces moved to appropriate type files
 /**
  * Class that processes and manages user messages.
  * Handles converting messages to prompts and extracting mentioned entities.
@@ -77,8 +78,10 @@ class UserMessage {
         }
         if (bAttachEnvironment) {
             let { projectPath } = await project_1.default.getProjectPath();
-            const environmentDetail = await this.getEnvironmentDetail(projectPath);
-            this.userMessages.push({ type: "text", text: environmentDetail });
+            if (projectPath) {
+                const environmentDetail = await this.getEnvironmentDetail(projectPath);
+                this.userMessages.push({ type: "text", text: environmentDetail });
+            }
         }
         return this.userMessages;
     }
@@ -105,12 +108,9 @@ class UserMessage {
      * @returns Promise with an array of MCP tools
      */
     async getMentionedMcpsTools() {
-        console.log("mentionedMCPs", this.mentionedMCPs);
         if (this.mentionedMCPs.length > 0) {
-            console.log("mentionedMCPs", this.mentionedMCPs);
-            let tools = await tools_1.default.listToolsFromToolBoxes(this.mentionedMCPs);
-            console.log("tools", tools);
-            return tools;
+            const { data } = await mcp_1.default.getTools(this.mentionedMCPs);
+            return data;
         }
         else {
             return [];

package/dist/core/messageManager.d.ts

@@ -1,12 +1,7 @@
 /// <reference types="node" />
 import WebSocket from 'ws';
 import { EventEmitter } from 'events';
-export interface PendingRequest {
-    resolve: (value: any) => void;
-    reject: (reason?: any) => void;
-    messageTypes: string[];
-    requestId?: string;
-}
+import type { PendingRequest } from '../types/commonTypes';
 /**
  * Centralized message manager for handling WebSocket communications
  */
@@ -28,6 +23,9 @@ export declare class MessageManager extends EventEmitter {
     handleMessage(response: any): void;
     /**
      * Send a message and wait for a specific response type
+     * @param message The message to send
+     * @param expectedResponseType The type of response to wait for
+     * @param timeout Optional timeout in milliseconds. If not provided or set to 0, will wait indefinitely
      */
     sendAndWaitForResponse<T = any>(message: any, expectedResponseType: string, timeout?: number): Promise<T>;
     /**