@codebolt/agent 5.0.8 → 5.0.9

package/dist/composablepattern/document.js

@@ -1,405 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-/**
- * @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

@@ -1,218 +0,0 @@
-"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

@@ -1,40 +0,0 @@
-/**
- * @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>;