@codebolt/agent 5.0.1 → 5.0.6

package/dist/systemprompt.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SystemPrompt class for loading and managing system prompts from YAML files
+ */
+declare class SystemPrompt {
+    private filepath;
+    private key;
+    /**
+     * Creates a SystemPrompt instance
+     * @param {string} filepath - Path to the YAML file containing prompts
+     * @param {string} key - Key identifier for the specific prompt
+     */
+    constructor(filepath?: string, key?: string);
+    /**
+     * Loads and returns the prompt text
+     * @returns {string} The prompt text
+     * @throws {Error} If file cannot be read or parsed
+     */
+    toPromptText(): string;
+}
+export { SystemPrompt };

package/dist/systemprompt.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemPrompt = void 0;
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * SystemPrompt class for loading and managing system prompts from YAML files
+ */
+class SystemPrompt {
+    /**
+     * Creates a SystemPrompt instance
+     * @param {string} filepath - Path to the YAML file containing prompts
+     * @param {string} key - Key identifier for the specific prompt
+     */
+    constructor(filepath = "", key = "") {
+        this.filepath = filepath;
+        this.key = key;
+    }
+    /**
+     * Loads and returns the prompt text
+     * @returns {string} The prompt text
+     * @throws {Error} If file cannot be read or parsed
+     */
+    toPromptText() {
+        try {
+            const absolutePath = path_1.default.resolve(this.filepath);
+            const fileContents = fs_1.default.readFileSync(absolutePath, 'utf8');
+            const data = js_yaml_1.default.load(fileContents);
+            if (!data || typeof data !== 'object') {
+                throw new Error('Invalid YAML structure');
+            }
+            if (!data[this.key]) {
+                throw new Error(`Prompt not found for key: ${this.key}`);
+            }
+            const promptData = data[this.key];
+            return typeof promptData === 'string' ? promptData : promptData.prompt;
+        }
+        catch (error) {
+            console.error(`SystemPrompt Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error; // Re-throw to allow caller handling
+        }
+    }
+}
+exports.SystemPrompt = SystemPrompt;

package/dist/taskInstruction.d.ts

@@ -0,0 +1,37 @@
+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.
+ */
+declare class TaskInstruction {
+    /** Available tools for the task */
+    tools: Tools;
+    /** Messages from the user for this task */
+    userMessages: UserMessageContent[];
+    /** The user message object containing input */
+    userMessage: UserMessage;
+    /** Path to the YAML file with task instructions */
+    filepath: string;
+    /** The section reference within the YAML file */
+    refsection: string;
+    /**
+     * Creates a new TaskInstruction instance.
+     *
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
+    constructor(tools: Tools | undefined, userMessage: UserMessage, filepath?: string, refsection?: string);
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     *
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
+    toPrompt(): Promise<UserMessages[]>;
+}
+export { TaskInstruction };

package/dist/taskInstruction.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskInstruction = void 0;
+/**
+ * Encapsulates task instructions and their related metadata.
+ * Handles loading and processing of task instructions from YAML files.
+ */
+const yaml = require('js-yaml');
+const fs = require('fs');
+const path = require('path');
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
+class TaskInstruction {
+    /**
+     * Creates a new TaskInstruction instance.
+     *
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
+    constructor(tools = {}, userMessage, filepath = "", refsection = "") {
+        /** Messages from the user for this task */
+        this.userMessages = [];
+        this.tools = tools;
+        this.userMessage = userMessage;
+        this.filepath = filepath;
+        this.refsection = refsection;
+    }
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     *
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
+    async toPrompt() {
+        try {
+            this.userMessages = await this.userMessage.toPrompt();
+            const fileContents = fs.readFileSync(path.resolve(this.filepath), 'utf8');
+            const data = yaml.load(fileContents);
+            const task = data[this.refsection];
+            this.userMessages.push({
+                type: "text",
+                text: `Task Description: ${task.description}\nExpected Output: ${task.expected_output}`
+            });
+            return this.userMessages;
+        }
+        catch (error) {
+            console.error(`Error processing task instruction: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.TaskInstruction = TaskInstruction;

package/dist/unified/agent/agent.js

@@ -42,11 +42,11 @@ class Agent {
                     // console.log('[Agent] Step completed, processing response');
                 }
                 const responseExecutor = new responseExecutor_1.ResponseExecutor({
-                    preToolCalProcessors: this.preToolCallProcessors,
+                    preToolCallProcessors: this.preToolCallProcessors,
                     postToolCallProcessors: this.postToolCallProcessors
                 });
                 const executionResult = await responseExecutor.executeResponse({
-                    initailUserMessage: reqMessage,
+                    initialUserMessage: reqMessage,
                     actualMessageSentToLLM: stepResult.actualMessageSentToLLM,
                     rawLLMOutput: stepResult.rawLLMResponse,
                     nextMessage: stepResult.nextMessage

package/dist/unified/agent/codeboltAgent.d.ts

@@ -0,0 +1,122 @@
+import { AgentConfig, MessageModifier, PostInferenceProcessor, PostToolCallProcessor, PreInferenceProcessor, PreToolCallProcessor } from "@codebolt/types/agent";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+/**
+ * Configuration options for CodeboltAgent
+ */
+export interface CodeboltAgentConfig extends AgentConfig {
+    /**
+     * Enable logging for debugging purposes.
+     * Defaults to true.
+     */
+    enableLogging?: boolean;
+}
+/**
+ * CodeboltAgent is a high-level agent class that:
+ * - Uses InitialPromptGenerator with configurable processors/modifiers
+ * - Runs an agent loop with AgentStep and ResponseExecutor
+ * - Handles tool execution and conversation flow automatically
+ * - Is triggered via processMessage (not via onMessage listener)
+ *
+ * @example
+ * ```typescript
+ * import { CodeboltAgent } from '@codebolt/agent/unified';
+ * import {
+ *     EnvironmentContextModifier,
+ *     CoreSystemPromptModifier,
+ *     DirectoryContextModifier,
+ *     IdeContextModifier,
+ *     AtFileProcessorModifier,
+ *     ToolInjectionModifier,
+ *     ChatHistoryMessageModifier
+ * } from '@codebolt/agent/processor-pieces';
+ *
+ * const systemPrompt = `You are an AI coding assistant...`;
+ *
+ * const agent = new CodeboltAgent({
+ *     instructions: systemPrompt,
+ *     processors: {
+ *         messageModifiers: [
+ *             new ChatHistoryMessageModifier({ enableChatHistory: true }),
+ *             new EnvironmentContextModifier({ enableFullContext: true }),
+ *             new DirectoryContextModifier(),
+ *             new IdeContextModifier({
+ *                 includeActiveFile: true,
+ *                 includeOpenFiles: true,
+ *                 includeCursorPosition: true,
+ *                 includeSelectedText: true
+ *             }),
+ *             new CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
+ *             new ToolInjectionModifier({ includeToolDescriptions: true }),
+ *             new AtFileProcessorModifier({ enableRecursiveSearch: true })
+ *         ],
+ *         preInferenceProcessors: [],
+ *         postInferenceProcessors: [],
+ *         preToolCallProcessors: [],
+ *         postToolCallProcessors: []
+ *     }
+ * });
+ *
+ * // Process a message (triggered from graph node)
+ * const result = await agent.processMessage(userMessage);
+ * ```
+ */
+export declare class CodeboltAgent {
+    private readonly config;
+    private readonly messageModifiers;
+    private readonly preInferenceProcessors;
+    private readonly postInferenceProcessors;
+    private readonly preToolCallProcessors;
+    private readonly postToolCallProcessors;
+    private readonly enableLogging;
+    private readonly baseSystemPrompt;
+    constructor(config: CodeboltAgentConfig);
+    /**
+     * Creates default message modifiers when none are provided
+     */
+    private createDefaultMessageModifiers;
+    /**
+     * Process a message through the agent pipeline.
+     * This is the main entry point - triggered from graph nodes.
+     */
+    processMessage(reqMessage: FlatUserMessage): Promise<{
+        success: boolean;
+        result: any;
+        error?: string;
+    }>;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): CodeboltAgentConfig;
+    /**
+     * Get all message modifiers
+     */
+    getMessageModifiers(): MessageModifier[];
+    /**
+     * Get all pre-inference processors
+     */
+    getPreInferenceProcessors(): PreInferenceProcessor[];
+    /**
+     * Get all post-inference processors
+     */
+    getPostInferenceProcessors(): PostInferenceProcessor[];
+    /**
+     * Get all pre-tool-call processors
+     */
+    getPreToolCallProcessors(): PreToolCallProcessor[];
+    /**
+     * Get all post-tool-call processors
+     */
+    getPostToolCallProcessors(): PostToolCallProcessor[];
+}
+/**
+ * Factory function to create a CodeboltAgent with common defaults
+ */
+export declare function createCodeboltAgent(options: {
+    systemPrompt: string;
+    messageModifiers?: MessageModifier[];
+    preInferenceProcessors?: PreInferenceProcessor[];
+    postInferenceProcessors?: PostInferenceProcessor[];
+    preToolCallProcessors?: PreToolCallProcessor[];
+    postToolCallProcessors?: PostToolCallProcessor[];
+    enableLogging?: boolean;
+}): CodeboltAgent;

package/dist/unified/agent/codeboltAgent.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeboltAgent = void 0;
+exports.createCodeboltAgent = createCodeboltAgent;
+const base_1 = require("../base");
+const responseExecutor_1 = require("../base/responseExecutor");
+const agentStep_1 = require("../base/agentStep");
+const processor_pieces_1 = require("../../processor-pieces");
+/**
+ * CodeboltAgent is a high-level agent class that:
+ * - Uses InitialPromptGenerator with configurable processors/modifiers
+ * - Runs an agent loop with AgentStep and ResponseExecutor
+ * - Handles tool execution and conversation flow automatically
+ * - Is triggered via processMessage (not via onMessage listener)
+ *
+ * @example
+ * ```typescript
+ * import { CodeboltAgent } from '@codebolt/agent/unified';
+ * import {
+ *     EnvironmentContextModifier,
+ *     CoreSystemPromptModifier,
+ *     DirectoryContextModifier,
+ *     IdeContextModifier,
+ *     AtFileProcessorModifier,
+ *     ToolInjectionModifier,
+ *     ChatHistoryMessageModifier
+ * } from '@codebolt/agent/processor-pieces';
+ *
+ * const systemPrompt = `You are an AI coding assistant...`;
+ *
+ * const agent = new CodeboltAgent({
+ *     instructions: systemPrompt,
+ *     processors: {
+ *         messageModifiers: [
+ *             new ChatHistoryMessageModifier({ enableChatHistory: true }),
+ *             new EnvironmentContextModifier({ enableFullContext: true }),
+ *             new DirectoryContextModifier(),
+ *             new IdeContextModifier({
+ *                 includeActiveFile: true,
+ *                 includeOpenFiles: true,
+ *                 includeCursorPosition: true,
+ *                 includeSelectedText: true
+ *             }),
+ *             new CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
+ *             new ToolInjectionModifier({ includeToolDescriptions: true }),
+ *             new AtFileProcessorModifier({ enableRecursiveSearch: true })
+ *         ],
+ *         preInferenceProcessors: [],
+ *         postInferenceProcessors: [],
+ *         preToolCallProcessors: [],
+ *         postToolCallProcessors: []
+ *     }
+ * });
+ *
+ * // Process a message (triggered from graph node)
+ * const result = await agent.processMessage(userMessage);
+ * ```
+ */
+class CodeboltAgent {
+    constructor(config) {
+        var _a, _b, _c, _d, _e, _f;
+        this.config = { ...config };
+        this.enableLogging = config.enableLogging !== false;
+        this.baseSystemPrompt = config.instructions || 'Based on User Message send reply';
+        // Use provided modifiers or default ones
+        this.messageModifiers = ((_b = (_a = config.processors) === null || _a === void 0 ? void 0 : _a.messageModifiers) === null || _b === void 0 ? void 0 : _b.length)
+            ? config.processors.messageModifiers
+            : this.createDefaultMessageModifiers(this.baseSystemPrompt);
+        this.preInferenceProcessors = ((_c = config.processors) === null || _c === void 0 ? void 0 : _c.preInferenceProcessors) || [];
+        this.postInferenceProcessors = ((_d = config.processors) === null || _d === void 0 ? void 0 : _d.postInferenceProcessors) || [];
+        this.preToolCallProcessors = ((_e = config.processors) === null || _e === void 0 ? void 0 : _e.preToolCallProcessors) || [];
+        this.postToolCallProcessors = ((_f = config.processors) === null || _f === void 0 ? void 0 : _f.postToolCallProcessors) || [];
+    }
+    /**
+     * Creates default message modifiers when none are provided
+     */
+    createDefaultMessageModifiers(systemPrompt) {
+        return [
+            // 1. Chat History
+            new processor_pieces_1.ChatHistoryMessageModifier({ enableChatHistory: true }),
+            // 2. Environment Context (date, OS)
+            new processor_pieces_1.EnvironmentContextModifier({ enableFullContext: true }),
+            // 3. Directory Context (folder structure)
+            new processor_pieces_1.DirectoryContextModifier(),
+            // 4. IDE Context (active file, opened files)
+            new processor_pieces_1.IdeContextModifier({
+                includeActiveFile: true,
+                includeOpenFiles: true,
+                includeCursorPosition: true,
+                includeSelectedText: true
+            }),
+            // 5. Core System Prompt (instructions)
+            new processor_pieces_1.CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
+            // 6. Tools (function declarations)
+            new processor_pieces_1.ToolInjectionModifier({ includeToolDescriptions: true }),
+            // 7. At-file processing (@file mentions)
+            new processor_pieces_1.AtFileProcessorModifier({ enableRecursiveSearch: true })
+        ];
+    }
+    /**
+     * Process a message through the agent pipeline.
+     * This is the main entry point - triggered from graph nodes.
+     */
+    async processMessage(reqMessage) {
+        try {
+            if (this.enableLogging) {
+                console.log('[CodeboltAgent] Processing message');
+            }
+            const promptGenerator = new base_1.InitialPromptGenerator({
+                processors: this.messageModifiers,
+                baseSystemPrompt: this.baseSystemPrompt,
+                enableLogging: this.enableLogging
+            });
+            let prompt = await promptGenerator.processMessage(reqMessage);
+            let completed = false;
+            while (!completed) {
+                const agentStep = new agentStep_1.AgentStep({
+                    preInferenceProcessors: this.preInferenceProcessors,
+                    postInferenceProcessors: this.postInferenceProcessors
+                });
+                const stepResult = await agentStep.executeStep(reqMessage, prompt);
+                prompt = stepResult.nextMessage;
+                const responseExecutor = new responseExecutor_1.ResponseExecutor({
+                    preToolCallProcessors: this.preToolCallProcessors,
+                    postToolCallProcessors: this.postToolCallProcessors
+                });
+                const executionResult = await responseExecutor.executeResponse({
+                    initialUserMessage: reqMessage,
+                    actualMessageSentToLLM: stepResult.actualMessageSentToLLM,
+                    rawLLMOutput: stepResult.rawLLMResponse,
+                    nextMessage: stepResult.nextMessage
+                });
+                completed = executionResult.completed;
+                prompt = executionResult.nextMessage;
+            }
+            if (this.enableLogging) {
+                console.log('[CodeboltAgent] Message processing completed');
+            }
+            return {
+                success: true,
+                result: prompt,
+                error: undefined
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            if (this.enableLogging) {
+                console.error('[CodeboltAgent] Execution failed:', error);
+            }
+            return {
+                success: false,
+                result: null,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get all message modifiers
+     */
+    getMessageModifiers() {
+        return [...this.messageModifiers];
+    }
+    /**
+     * Get all pre-inference processors
+     */
+    getPreInferenceProcessors() {
+        return [...this.preInferenceProcessors];
+    }
+    /**
+     * Get all post-inference processors
+     */
+    getPostInferenceProcessors() {
+        return [...this.postInferenceProcessors];
+    }
+    /**
+     * Get all pre-tool-call processors
+     */
+    getPreToolCallProcessors() {
+        return [...this.preToolCallProcessors];
+    }
+    /**
+     * Get all post-tool-call processors
+     */
+    getPostToolCallProcessors() {
+        return [...this.postToolCallProcessors];
+    }
+}
+exports.CodeboltAgent = CodeboltAgent;
+/**
+ * Factory function to create a CodeboltAgent with common defaults
+ */
+function createCodeboltAgent(options) {
+    return new CodeboltAgent({
+        instructions: options.systemPrompt,
+        processors: {
+            messageModifiers: options.messageModifiers || [],
+            preInferenceProcessors: options.preInferenceProcessors || [],
+            postInferenceProcessors: options.postInferenceProcessors || [],
+            preToolCallProcessors: options.preToolCallProcessors || [],
+            postToolCallProcessors: options.postToolCallProcessors || []
+        },
+        enableLogging: options.enableLogging
+    });
+}

package/dist/unified/base/initialPromptGenerator.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InitialPromptGenerator = void 0;
 exports.createUnifiedMessageProcessor = createUnifiedMessageProcessor;
 const types_1 = require("../types/types");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 /**
  * Initial prompt generator that combines message modifiers with unified processing
  */
@@ -50,10 +54,20 @@ class InitialPromptGenerator {
                     // Continue with other modifiers
                 }
             }
-            createdMessage.message.messages.push({
-                role: 'assistant',
-                content: "Got it. Thanks for the context!"
-            });
+            const lastMessage = createdMessage.message.messages[createdMessage.message.messages.length - 1];
+            if (!lastMessage || lastMessage.role !== 'system') {
+                createdMessage.message.messages.push({
+                    role: 'assistant',
+                    content: "Got it. Thanks for the context!"
+                });
+            }
+            let { todos } = await codeboltjs_1.default.todo.getAllIncompleteTodos();
+            if (todos && todos.length == 0) {
+                createdMessage.message.messages.push({
+                    role: 'user',
+                    content: "<system-reminder>\nThis is a reminder that your todo list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a todo list please use the TodoWrite tool to create one. If not, please feel free to ignore. Again do not mention this message to the user.\n</system-reminder>"
+                });
+            }
             createdMessage.message.messages.push({
                 role: 'user',
                 content: content.trim()

package/dist/unified/base/responseExecutor.d.ts

@@ -1,10 +1,11 @@
 import { AgentResponseExecutor, PostToolCallProcessor, PreToolCallProcessor, ResponseInput, ResponseOutput } from '@codebolt/types/agent';
 export declare class ResponseExecutor implements AgentResponseExecutor {
-    private preToolCalProcessors;
+    private preToolCallProcessors;
     private postToolCallProcessors;
     private completed;
+    private finalMessage;
     constructor(options: {
-        preToolCalProcessors: PreToolCallProcessor[];
+        preToolCallProcessors: PreToolCallProcessor[];
         postToolCallProcessors: PostToolCallProcessor[];
     });
     executeResponse(input: ResponseInput): Promise<ResponseOutput>;