@codebolt/agent 1.1.0 → 2.2.2

package/dist/composablepattern/document.js

@@ -0,0 +1,405 @@
+"use strict";
+/**
+ * @fileoverview Document handling for Composable Agent Pattern
+ * @description Provides document processing, chunking, and embedding capabilities
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MDocument = void 0;
+/**
+ * Document processing and management class
+ */
+class MDocument {
+    constructor(content, type = 'text', metadata = {}) {
+        this.content = content;
+        this.type = type;
+        this.metadata = {
+            ...metadata,
+            createdAt: new Date().toISOString(),
+            wordCount: this.countWords(content),
+            charCount: content.length
+        };
+    }
+    /**
+     * Create MDocument from plain text
+     *
+     * @param text - Plain text content
+     * @param metadata - Optional metadata
+     * @returns MDocument instance
+     */
+    static fromText(text, metadata) {
+        return new MDocument(text, 'text', metadata);
+    }
+    /**
+     * Create MDocument from markdown
+     *
+     * @param markdown - Markdown content
+     * @param metadata - Optional metadata
+     * @returns MDocument instance
+     */
+    static fromMarkdown(markdown, metadata) {
+        return new MDocument(markdown, 'markdown', metadata);
+    }
+    /**
+     * Create MDocument from JSON
+     *
+     * @param json - JSON object or string
+     * @param metadata - Optional metadata
+     * @returns MDocument instance
+     */
+    static fromJSON(json, metadata) {
+        const content = typeof json === 'string' ? json : JSON.stringify(json, null, 2);
+        return new MDocument(content, 'json', metadata);
+    }
+    /**
+     * Create MDocument from file path
+     *
+     * @param filePath - Path to the file
+     * @param metadata - Optional metadata
+     * @returns Promise<MDocument> instance
+     */
+    static async fromFile(filePath, metadata) {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        const path = await Promise.resolve().then(() => __importStar(require('path')));
+        const content = await fs.readFile(filePath, 'utf-8');
+        const extension = path.extname(filePath).toLowerCase();
+        let type = 'text';
+        if (extension === '.md')
+            type = 'markdown';
+        else if (extension === '.json')
+            type = 'json';
+        else if (extension === '.xml')
+            type = 'xml';
+        const fileMetadata = {
+            ...metadata,
+            filePath,
+            fileName: path.basename(filePath),
+            fileExtension: extension
+        };
+        return new MDocument(content, type, fileMetadata);
+    }
+    /**
+     * Get document content
+     */
+    getContent() {
+        return this.content;
+    }
+    /**
+     * Get document type
+     */
+    getType() {
+        return this.type;
+    }
+    /**
+     * Get document metadata
+     */
+    getMetadata() {
+        return { ...this.metadata };
+    }
+    /**
+     * Update document metadata
+     *
+     * @param metadata - Metadata to merge
+     */
+    updateMetadata(metadata) {
+        this.metadata = {
+            ...this.metadata,
+            ...metadata,
+            updatedAt: new Date().toISOString()
+        };
+    }
+    /**
+     * Chunk the document into smaller pieces
+     *
+     * @param options - Chunking options
+     * @returns Array of text chunks
+     */
+    chunk(options = {}) {
+        const { size = 1000, overlap = 100, strategy = 'paragraph' } = options;
+        let chunks;
+        switch (strategy) {
+            case 'sentence':
+                chunks = this.chunkBySentence(size, overlap);
+                break;
+            case 'paragraph':
+                chunks = this.chunkByParagraph(size, overlap);
+                break;
+            case 'semantic':
+                chunks = this.chunkSemantic(size, overlap);
+                break;
+            case 'fixed':
+            default:
+                chunks = this.chunkFixed(size, overlap);
+                break;
+        }
+        this.chunks = chunks;
+        this.updateMetadata({
+            chunkCount: chunks.length,
+            chunkStrategy: strategy,
+            chunkSize: size,
+            chunkOverlap: overlap
+        });
+        return chunks;
+    }
+    /**
+     * Get existing chunks or create them if they don't exist
+     */
+    getChunks() {
+        if (!this.chunks) {
+            return this.chunk();
+        }
+        return this.chunks;
+    }
+    /**
+     * Set embeddings for the document or its chunks
+     *
+     * @param embeddings - Array of embedding vectors
+     */
+    setEmbeddings(embeddings) {
+        var _a;
+        this.embeddings = embeddings;
+        this.updateMetadata({
+            hasEmbeddings: true,
+            embeddingCount: embeddings.length,
+            embeddingDimension: ((_a = embeddings[0]) === null || _a === void 0 ? void 0 : _a.length) || 0
+        });
+    }
+    /**
+     * Get embeddings
+     */
+    getEmbeddings() {
+        return this.embeddings;
+    }
+    /**
+     * Convert to processed document format
+     */
+    toProcessedDocument() {
+        return {
+            content: this.content,
+            chunks: this.chunks,
+            metadata: this.metadata,
+            embeddings: this.embeddings
+        };
+    }
+    /**
+     * Convert to plain object
+     */
+    toJSON() {
+        return {
+            content: this.content,
+            type: this.type,
+            metadata: this.metadata,
+            chunks: this.chunks,
+            embeddings: this.embeddings
+        };
+    }
+    /**
+     * Create MDocument from processed document
+     *
+     * @param processed - Processed document data
+     * @returns MDocument instance
+     */
+    static fromProcessedDocument(processed) {
+        const doc = new MDocument(processed.content, processed.metadata.type || 'text', processed.metadata);
+        if (processed.chunks) {
+            doc.chunks = processed.chunks;
+        }
+        if (processed.embeddings) {
+            doc.embeddings = processed.embeddings;
+        }
+        return doc;
+    }
+    /**
+     * Extract text content based on document type
+     */
+    extractText() {
+        switch (this.type) {
+            case 'markdown':
+                return this.extractMarkdownText();
+            case 'json':
+                return this.extractJSONText();
+            case 'xml':
+                return this.extractXMLText();
+            default:
+                return this.content;
+        }
+    }
+    /**
+     * Count words in content
+     */
+    countWords(content) {
+        return content.trim().split(/\s+/).filter(word => word.length > 0).length;
+    }
+    /**
+     * Fixed-size chunking with overlap
+     */
+    chunkFixed(size, overlap) {
+        const chunks = [];
+        let start = 0;
+        while (start < this.content.length) {
+            const end = Math.min(start + size, this.content.length);
+            chunks.push(this.content.slice(start, end));
+            if (end === this.content.length)
+                break;
+            start = end - overlap;
+        }
+        return chunks;
+    }
+    /**
+     * Sentence-based chunking
+     */
+    chunkBySentence(size, overlap) {
+        const sentences = this.content.split(/[.!?]+/).filter(s => s.trim().length > 0);
+        const chunks = [];
+        let currentChunk = '';
+        let currentSize = 0;
+        for (const sentence of sentences) {
+            const sentenceSize = sentence.length;
+            if (currentSize + sentenceSize > size && currentChunk) {
+                chunks.push(currentChunk.trim());
+                // Handle overlap by keeping some sentences
+                if (overlap > 0) {
+                    const overlapSentences = currentChunk.split(/[.!?]+/).slice(-Math.ceil(overlap / 100));
+                    currentChunk = overlapSentences.join('. ') + '. ';
+                    currentSize = currentChunk.length;
+                }
+                else {
+                    currentChunk = '';
+                    currentSize = 0;
+                }
+            }
+            currentChunk += sentence + '. ';
+            currentSize += sentenceSize;
+        }
+        if (currentChunk.trim()) {
+            chunks.push(currentChunk.trim());
+        }
+        return chunks;
+    }
+    /**
+     * Paragraph-based chunking
+     */
+    chunkByParagraph(size, overlap) {
+        const paragraphs = this.content.split(/\n\s*\n/).filter(p => p.trim().length > 0);
+        const chunks = [];
+        let currentChunk = '';
+        let currentSize = 0;
+        for (const paragraph of paragraphs) {
+            const paragraphSize = paragraph.length;
+            if (currentSize + paragraphSize > size && currentChunk) {
+                chunks.push(currentChunk.trim());
+                // Handle overlap
+                if (overlap > 0) {
+                    const words = currentChunk.split(/\s+/);
+                    const overlapWords = words.slice(-overlap);
+                    currentChunk = overlapWords.join(' ') + ' ';
+                    currentSize = currentChunk.length;
+                }
+                else {
+                    currentChunk = '';
+                    currentSize = 0;
+                }
+            }
+            currentChunk += paragraph + '\n\n';
+            currentSize += paragraphSize;
+        }
+        if (currentChunk.trim()) {
+            chunks.push(currentChunk.trim());
+        }
+        return chunks;
+    }
+    /**
+     * Semantic chunking (basic implementation)
+     */
+    chunkSemantic(size, overlap) {
+        // For now, fall back to paragraph chunking
+        // In a full implementation, this would use NLP techniques
+        return this.chunkByParagraph(size, overlap);
+    }
+    /**
+     * Extract text from markdown
+     */
+    extractMarkdownText() {
+        // Simple markdown text extraction
+        return this.content
+            .replace(/^#+\s+/gm, '') // Remove headers
+            .replace(/\*\*(.*?)\*\*/g, '$1') // Remove bold
+            .replace(/\*(.*?)\*/g, '$1') // Remove italic
+            .replace(/`(.*?)`/g, '$1') // Remove inline code
+            .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Remove links
+            .replace(/```[\s\S]*?```/g, '') // Remove code blocks
+            .trim();
+    }
+    /**
+     * Extract text from JSON
+     */
+    extractJSONText() {
+        try {
+            const obj = JSON.parse(this.content);
+            return this.extractTextFromObject(obj);
+        }
+        catch {
+            return this.content;
+        }
+    }
+    /**
+     * Extract text from XML
+     */
+    extractXMLText() {
+        // Simple XML text extraction
+        return this.content.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+    }
+    /**
+     * Recursively extract text from object
+     */
+    extractTextFromObject(obj) {
+        if (typeof obj === 'string')
+            return obj;
+        if (typeof obj === 'number')
+            return obj.toString();
+        if (typeof obj === 'boolean')
+            return obj.toString();
+        if (obj === null || obj === undefined)
+            return '';
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.extractTextFromObject(item)).join(' ');
+        }
+        if (typeof obj === 'object') {
+            return Object.values(obj).map(value => this.extractTextFromObject(value)).join(' ');
+        }
+        return '';
+    }
+}
+exports.MDocument = MDocument;

package/dist/composablepattern/examples/codebolt-integration-example.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview CodeBolt Integration Example
+ * @description Example showing how to use ComposableAgent within CodeBolt's onMessage system
+ */
+import { ComposableAgent } from '../index';
+declare const myAgent: ComposableAgent;
+declare const flexibleAgent: ComposableAgent;
+declare const researchAgent: ComposableAgent;
+declare const writingAgent: ComposableAgent;
+declare const workflowAgent: ComposableAgent;
+declare const complexWorkflow: import("../workflow").Workflow;
+export { myAgent, flexibleAgent, researchAgent, writingAgent, workflowAgent, complexWorkflow };

package/dist/composablepattern/examples/codebolt-integration-example.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * @fileoverview CodeBolt Integration Example
+ * @description Example showing how to use ComposableAgent within CodeBolt's onMessage system
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.complexWorkflow = exports.workflowAgent = exports.writingAgent = exports.researchAgent = exports.flexibleAgent = exports.myAgent = void 0;
+const index_1 = require("../index");
+// This would typically be in a separate file, e.g., agent.js
+const codebolt = require('@codebolt/codeboltjs');
+// Create your tools
+const weatherTool = (0, index_1.createTool)({
+    id: 'get-weather',
+    description: 'Get current weather for a location',
+    inputSchema: index_1.z.object({
+        location: index_1.z.string().describe('City name'),
+    }),
+    outputSchema: index_1.z.object({
+        temperature: index_1.z.number(),
+        conditions: index_1.z.string(),
+        location: index_1.z.string(),
+    }),
+    execute: async ({ context }) => {
+        // Mock weather data
+        return {
+            temperature: 22,
+            conditions: 'Sunny',
+            location: context.location
+        };
+    },
+});
+// Create your composable agent
+const myAgent = new index_1.ComposableAgent({
+    name: 'Weather Assistant',
+    instructions: `
+    You are a helpful weather assistant. 
+    Use the weather tool to get current weather information.
+    Be friendly and provide helpful responses.
+  `,
+    model: 'weathermodel', // References configuration in codeboltagents.yaml
+    tools: { weatherTool },
+    processing: {
+        // Configure what to process automatically
+        processMentionedMCPs: true, // Auto-add mentioned MCPs as tools
+        processRemixPrompt: true, // Use remix prompt to enhance instructions
+        processMentionedFiles: true, // Include mentioned file contents
+        processMentionedAgents: true // Add mentioned agents as sub-agents
+    }
+});
+exports.myAgent = myAgent;
+// CodeBolt integration - this is how you'd use it in your agent
+codebolt.onMessage(async (reqMessage) => {
+    try {
+        console.log('Received message:', reqMessage);
+        // Save the user message globally so the agent can access it
+        (0, index_1.saveUserMessage)(reqMessage, {
+            // You can override the auto-detection here if needed
+            processMentionedMCPs: true,
+            processRemixPrompt: true,
+            processMentionedFiles: false, // Don't process files for this agent
+            processMentionedAgents: true
+        });
+        // Now simply run the agent - it will automatically use the saved user context
+        const result = await myAgent.run();
+        if (result.success) {
+            return result.message;
+        }
+        else {
+            console.error('Agent failed:', result.error);
+            return 'Sorry, I encountered an error processing your request.';
+        }
+    }
+    catch (error) {
+        console.error('Error in agent execution:', error);
+        return 'Sorry, something went wrong.';
+    }
+});
+// ================================
+// Alternative Example: Manual Configuration per Message
+// ================================
+const flexibleAgent = new index_1.ComposableAgent({
+    name: 'Flexible Assistant',
+    instructions: 'I am a flexible assistant that adapts based on user context.',
+    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
+    tools: { weatherTool }
+    // No processing config - will use global user config
+});
+exports.flexibleAgent = flexibleAgent;
+codebolt.onMessage(async (reqMessage) => {
+    var _a, _b;
+    try {
+        // Analyze the message to determine what to process
+        const shouldProcessMCPs = ((_a = reqMessage.mentionedMCPs) === null || _a === void 0 ? void 0 : _a.length) > 0;
+        const shouldProcessFiles = (_b = reqMessage.mentionedFiles) === null || _b === void 0 ? void 0 : _b.some((file) => file.endsWith('.json') || file.endsWith('.yaml'));
+        // Save with custom configuration
+        (0, index_1.saveUserMessage)(reqMessage, {
+            processMentionedMCPs: shouldProcessMCPs,
+            processRemixPrompt: true,
+            processMentionedFiles: shouldProcessFiles,
+            processMentionedAgents: false // Don't use sub-agents for this example
+        });
+        // Run the agent
+        const result = await flexibleAgent.run();
+        return result.success ? result.message : 'Error occurred';
+    }
+    catch (error) {
+        console.error('Error:', error);
+        return 'Error processing request';
+    }
+});
+// ================================
+// Example: Multiple Agents with Shared Context
+// ================================
+const researchAgent = new index_1.ComposableAgent({
+    name: 'Research Agent',
+    instructions: 'Research and gather information on topics.',
+    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
+    processing: { processMentionedFiles: true } // This agent processes files
+});
+exports.researchAgent = researchAgent;
+const writingAgent = new index_1.ComposableAgent({
+    name: 'Writing Agent',
+    instructions: 'Write content based on research and requirements.',
+    model: 'gpt-4o-mini', // References configuration in codeboltagents.yaml
+    processing: { processRemixPrompt: true } // This agent uses remix prompts
+});
+exports.writingAgent = writingAgent;
+codebolt.onMessage(async (reqMessage) => {
+    try {
+        // Save user message once for all agents to use
+        (0, index_1.saveUserMessage)(reqMessage);
+        let result;
+        // Determine which agent to use based on message content
+        if (reqMessage.userMessage.toLowerCase().includes('research')) {
+            result = await researchAgent.run();
+        }
+        else if (reqMessage.userMessage.toLowerCase().includes('write')) {
+            result = await writingAgent.run();
+        }
+        else {
+            // Use the default agent
+            result = await myAgent.run();
+        }
+        return result.success ? result.message : 'Error occurred';
+    }
+    catch (error) {
+        console.error('Error:', error);
+        return 'Error processing request';
+    }
+});
+// ================================
+// Example: Workflow with Global Context
+// ================================
+const index_2 = require("../index");
+const workflowAgent = new index_1.ComposableAgent({
+    name: 'Workflow Agent',
+    instructions: 'I coordinate complex multi-step tasks.',
+    model: 'gpt-4o-mini' // References configuration in codeboltagents.yaml
+});
+exports.workflowAgent = workflowAgent;
+const complexWorkflow = (0, index_2.createWorkflow)({
+    name: 'Research and Write Workflow',
+    initialData: {}, // Will be populated from user context
+    steps: [
+        // Extract user context into workflow data
+        (0, index_2.createSimpleStep)({
+            id: 'setup-context',
+            name: 'Setup Workflow Context',
+            execute: () => {
+                const userMsg = (0, index_1.getUserMessage)();
+                const files = (0, index_1.getMentionedFiles)();
+                const mcps = (0, index_1.getMentionedMCPs)();
+                return {
+                    userMessage: (userMsg === null || userMsg === void 0 ? void 0 : userMsg.userMessage) || '',
+                    mentionedFiles: files,
+                    mentionedMCPs: mcps,
+                    setupComplete: true
+                };
+            }
+        }),
+        // Use agent step that automatically gets user context
+        (0, index_2.createAgentStep)({
+            id: 'research-step',
+            name: 'Research Phase',
+            agent: researchAgent,
+            messageTemplate: 'Research this topic: {{userMessage}}',
+            outputMapping: { 'researchData': 'agentResult.message' }
+        }),
+        (0, index_2.createAgentStep)({
+            id: 'writing-step',
+            name: 'Writing Phase',
+            agent: writingAgent,
+            messageTemplate: 'Write content based on: {{researchData}}',
+            outputMapping: { 'finalContent': 'agentResult.message' }
+        })
+    ]
+});
+exports.complexWorkflow = complexWorkflow;
+codebolt.onMessage(async (reqMessage) => {
+    try {
+        // Save user message for all agents and workflow steps to use
+        (0, index_1.saveUserMessage)(reqMessage);
+        if (reqMessage.userMessage.includes('complex task')) {
+            // Use workflow for complex tasks
+            const workflowResult = await complexWorkflow.execute();
+            return workflowResult.success ? workflowResult.data.finalContent : 'Workflow failed';
+        }
+        else {
+            // Use simple agent for regular tasks
+            const result = await workflowAgent.run();
+            return result.success ? result.message : 'Agent failed';
+        }
+    }
+    catch (error) {
+        console.error('Error:', error);
+        return 'Error processing request';
+    }
+});

package/dist/composablepattern/examples/codebolt-storage-example.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Example demonstrating CodeBolt backend storage for ComposableAgent
+ * @description Shows how to use CodeBolt's state and memory functions instead of SQLite
+ */
+import { ComposableAgent } from '../index';
+/**
+ * Example: Weather Agent with CodeBolt Agent State Storage
+ * Data is stored in CodeBolt's agent state backend
+ */
+export declare const weatherAgentWithAgentStorage: ComposableAgent;
+/**
+ * Example: Task Management Agent with CodeBolt Project State Storage
+ * Data is stored in CodeBolt's project state backend
+ */
+export declare const taskAgentWithProjectStorage: ComposableAgent;
+/**
+ * Example: Knowledge Agent with CodeBolt Memory Database Storage
+ * Data is stored in CodeBolt's in-memory database backend
+ */
+export declare const knowledgeAgentWithDbStorage: ComposableAgent;
+/**
+ * Example usage within CodeBolt onMessage
+ */
+export declare function setupCodeBoltStorageExample(): void;
+/**
+ * Example: Custom storage configuration
+ */
+export declare function createCustomStorageAgent(): ComposableAgent;
+/**
+ * Example: Multiple agents with different storage backends
+ */
+export declare function setupMultiStorageAgents(): {
+    sessionAgent: ComposableAgent;
+    globalAgent: ComposableAgent;
+    cacheAgent: ComposableAgent;
+};
+/**
+ * Storage comparison and migration helper
+ */
+export declare function storageComparison(): Promise<void>;