@codebolt/agent 1.1.0 → 2.2.2

package/dist/composablepattern/codebolt-storage.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * @fileoverview CodeBolt Backend Storage Provider for Composable Agent Pattern
+ * @description Uses CodeBolt's state and memory functions instead of SQLite for storage
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeBoltProjectStore = exports.CodeBoltMemoryStore = exports.CodeBoltAgentStore = void 0;
+exports.createCodeBoltStore = createCodeBoltStore;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+/**
+ * Storage provider that uses CodeBolt's agent state backend
+ * Data is persisted in the CodeBolt application's agent state
+ */
+class CodeBoltAgentStore {
+    constructor(prefix = 'composable_agent') {
+        this.prefix = prefix;
+    }
+    getFullKey(key) {
+        return `${this.prefix}_${key}`;
+    }
+    async get(key) {
+        try {
+            const fullKey = this.getFullKey(key);
+            const response = await codeboltjs_1.default.cbstate.getAgentState();
+            if (response.success && response.data && response.data[fullKey]) {
+                const value = response.data[fullKey];
+                try {
+                    return JSON.parse(value);
+                }
+                catch (error) {
+                    return value;
+                }
+            }
+            return undefined;
+        }
+        catch (error) {
+            console.error('CodeBoltAgentStore.get error:', error);
+            return undefined;
+        }
+    }
+    async set(key, value) {
+        try {
+            const fullKey = this.getFullKey(key);
+            const serializedValue = typeof value === 'string'
+                ? value
+                : JSON.stringify(value);
+            await codeboltjs_1.default.cbstate.addToAgentState(fullKey, serializedValue);
+        }
+        catch (error) {
+            console.error('CodeBoltAgentStore.set error:', error);
+            throw error;
+        }
+    }
+    async delete(key) {
+        try {
+            const fullKey = this.getFullKey(key);
+            // CodeBolt agent state doesn't have direct delete, so we set to null
+            await codeboltjs_1.default.cbstate.addToAgentState(fullKey, 'null');
+        }
+        catch (error) {
+            console.error('CodeBoltAgentStore.delete error:', error);
+            throw error;
+        }
+    }
+    async keys() {
+        try {
+            const response = await codeboltjs_1.default.cbstate.getAgentState();
+            if (response.success && response.data) {
+                const allKeys = Object.keys(response.data);
+                const prefixedKeys = allKeys.filter(key => key.startsWith(`${this.prefix}_`));
+                // Remove prefix and filter out null values
+                const result = [];
+                for (const prefixedKey of prefixedKeys) {
+                    const value = response.data[prefixedKey];
+                    if (value !== 'null') {
+                        result.push(prefixedKey.replace(`${this.prefix}_`, ''));
+                    }
+                }
+                return result;
+            }
+            return [];
+        }
+        catch (error) {
+            console.error('CodeBoltAgentStore.keys error:', error);
+            return [];
+        }
+    }
+    async clear() {
+        try {
+            const keys = await this.keys();
+            // Delete all keys by setting them to null
+            for (const key of keys) {
+                await this.delete(key);
+            }
+        }
+        catch (error) {
+            console.error('CodeBoltAgentStore.clear error:', error);
+            throw error;
+        }
+    }
+}
+exports.CodeBoltAgentStore = CodeBoltAgentStore;
+/**
+ * Storage provider that uses CodeBolt's in-memory database (dbmemory)
+ * Data is persisted in the CodeBolt application's memory database
+ */
+class CodeBoltMemoryStore {
+    constructor(prefix = 'composable_agent') {
+        this.prefix = prefix;
+    }
+    getFullKey(key) {
+        return `${this.prefix}_${key}`;
+    }
+    async get(key) {
+        try {
+            const fullKey = this.getFullKey(key);
+            const response = await codeboltjs_1.default.dbmemory.getKnowledge(fullKey);
+            if (response.success && response.data !== undefined) {
+                return response.data;
+            }
+            return undefined;
+        }
+        catch (error) {
+            console.error('CodeBoltMemoryStore.get error:', error);
+            return undefined;
+        }
+    }
+    async set(key, value) {
+        try {
+            const fullKey = this.getFullKey(key);
+            await codeboltjs_1.default.dbmemory.addKnowledge(fullKey, value);
+        }
+        catch (error) {
+            console.error('CodeBoltMemoryStore.set error:', error);
+            throw error;
+        }
+    }
+    async delete(key) {
+        try {
+            const fullKey = this.getFullKey(key);
+            // CodeBolt dbmemory doesn't have direct delete, so we set to null
+            await codeboltjs_1.default.dbmemory.addKnowledge(fullKey, null);
+        }
+        catch (error) {
+            console.error('CodeBoltMemoryStore.delete error:', error);
+            throw error;
+        }
+    }
+    async keys() {
+        try {
+            // CodeBolt dbmemory doesn't have a keys() method
+            // We'll need to maintain a key index
+            const indexKey = `${this.prefix}_key_index`;
+            const response = await codeboltjs_1.default.dbmemory.getKnowledge(indexKey);
+            if (response.success && Array.isArray(response.data)) {
+                // Filter out deleted keys (those with null values)
+                const validKeys = [];
+                for (const key of response.data) {
+                    const value = await this.get(key);
+                    if (value !== null) {
+                        validKeys.push(key);
+                    }
+                }
+                return validKeys;
+            }
+            return [];
+        }
+        catch (error) {
+            console.error('CodeBoltMemoryStore.keys error:', error);
+            return [];
+        }
+    }
+    async clear() {
+        try {
+            const keys = await this.keys();
+            // Delete all keys
+            for (const key of keys) {
+                await this.delete(key);
+            }
+            // Clear the key index
+            const indexKey = `${this.prefix}_key_index`;
+            await codeboltjs_1.default.dbmemory.addKnowledge(indexKey, []);
+        }
+        catch (error) {
+            console.error('CodeBoltMemoryStore.clear error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Override set to maintain key index
+     */
+    async setWithIndex(key, value) {
+        try {
+            // Update the key index
+            const indexKey = `${this.prefix}_key_index`;
+            const response = await codeboltjs_1.default.dbmemory.getKnowledge(indexKey);
+            let keyIndex = [];
+            if (response.success && Array.isArray(response.data)) {
+                keyIndex = response.data;
+            }
+            if (!keyIndex.includes(key)) {
+                keyIndex.push(key);
+                await codeboltjs_1.default.dbmemory.addKnowledge(indexKey, keyIndex);
+            }
+            // Set the actual value
+            await this.set(key, value);
+        }
+        catch (error) {
+            console.error('CodeBoltMemoryStore.setWithIndex error:', error);
+            throw error;
+        }
+    }
+}
+exports.CodeBoltMemoryStore = CodeBoltMemoryStore;
+/**
+ * Storage provider that uses CodeBolt's project state backend
+ * Data is persisted in the CodeBolt application's project state
+ */
+class CodeBoltProjectStore {
+    constructor(prefix = 'composable_agent') {
+        this.prefix = prefix;
+    }
+    getFullKey(key) {
+        return `${this.prefix}_${key}`;
+    }
+    async get(key) {
+        try {
+            const fullKey = this.getFullKey(key);
+            const response = await codeboltjs_1.default.cbstate.getProjectState();
+            if (response.success && response.data && response.data[fullKey] !== undefined) {
+                return response.data[fullKey];
+            }
+            return undefined;
+        }
+        catch (error) {
+            console.error('CodeBoltProjectStore.get error:', error);
+            return undefined;
+        }
+    }
+    async set(key, value) {
+        try {
+            const fullKey = this.getFullKey(key);
+            await codeboltjs_1.default.cbstate.updateProjectState(fullKey, value);
+        }
+        catch (error) {
+            console.error('CodeBoltProjectStore.set error:', error);
+            throw error;
+        }
+    }
+    async delete(key) {
+        try {
+            const fullKey = this.getFullKey(key);
+            // Set to null to indicate deletion
+            await codeboltjs_1.default.cbstate.updateProjectState(fullKey, null);
+        }
+        catch (error) {
+            console.error('CodeBoltProjectStore.delete error:', error);
+            throw error;
+        }
+    }
+    async keys() {
+        try {
+            const response = await codeboltjs_1.default.cbstate.getProjectState();
+            if (response.success && response.data) {
+                const allKeys = Object.keys(response.data);
+                const prefixedKeys = allKeys.filter(key => key.startsWith(`${this.prefix}_`));
+                // Remove prefix and filter out null values
+                const result = [];
+                for (const prefixedKey of prefixedKeys) {
+                    const value = response.data[prefixedKey];
+                    if (value !== null) {
+                        result.push(prefixedKey.replace(`${this.prefix}_`, ''));
+                    }
+                }
+                return result;
+            }
+            return [];
+        }
+        catch (error) {
+            console.error('CodeBoltProjectStore.keys error:', error);
+            return [];
+        }
+    }
+    async clear() {
+        try {
+            const keys = await this.keys();
+            // Delete all keys by setting them to null
+            for (const key of keys) {
+                await this.delete(key);
+            }
+        }
+        catch (error) {
+            console.error('CodeBoltProjectStore.clear error:', error);
+            throw error;
+        }
+    }
+}
+exports.CodeBoltProjectStore = CodeBoltProjectStore;
+/**
+ * Factory function to create appropriate CodeBolt storage provider
+ *
+ * @param config - Storage configuration
+ * @returns StorageProvider instance
+ */
+function createCodeBoltStore(config) {
+    const { type, prefix = 'composable_agent' } = config;
+    switch (type) {
+        case 'agent':
+            return new CodeBoltAgentStore(prefix);
+        case 'memory':
+            return new CodeBoltMemoryStore(prefix);
+        case 'project':
+            return new CodeBoltProjectStore(prefix);
+        default:
+            throw new Error(`Unknown CodeBolt storage type: ${type}`);
+    }
+}

package/dist/composablepattern/document.d.ts

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview Document handling for Composable Agent Pattern
+ * @description Provides document processing, chunking, and embedding capabilities
+ */
+import type { DocumentConfig, ProcessedDocument } from './types';
+/**
+ * Document processing and management class
+ */
+export declare class MDocument {
+    private content;
+    private type;
+    private metadata;
+    private chunks?;
+    private embeddings?;
+    constructor(content: string, type?: string, metadata?: Record<string, any>);
+    /**
+     * Create MDocument from plain text
+     *
+     * @param text - Plain text content
+     * @param metadata - Optional metadata
+     * @returns MDocument instance
+     */
+    static fromText(text: string, metadata?: Record<string, any>): MDocument;
+    /**
+     * Create MDocument from markdown
+     *
+     * @param markdown - Markdown content
+     * @param metadata - Optional metadata
+     * @returns MDocument instance
+     */
+    static fromMarkdown(markdown: string, metadata?: Record<string, any>): MDocument;
+    /**
+     * Create MDocument from JSON
+     *
+     * @param json - JSON object or string
+     * @param metadata - Optional metadata
+     * @returns MDocument instance
+     */
+    static fromJSON(json: any, metadata?: Record<string, any>): MDocument;
+    /**
+     * Create MDocument from file path
+     *
+     * @param filePath - Path to the file
+     * @param metadata - Optional metadata
+     * @returns Promise<MDocument> instance
+     */
+    static fromFile(filePath: string, metadata?: Record<string, any>): Promise<MDocument>;
+    /**
+     * Get document content
+     */
+    getContent(): string;
+    /**
+     * Get document type
+     */
+    getType(): string;
+    /**
+     * Get document metadata
+     */
+    getMetadata(): Record<string, any>;
+    /**
+     * Update document metadata
+     *
+     * @param metadata - Metadata to merge
+     */
+    updateMetadata(metadata: Record<string, any>): void;
+    /**
+     * Chunk the document into smaller pieces
+     *
+     * @param options - Chunking options
+     * @returns Array of text chunks
+     */
+    chunk(options?: {
+        size?: number;
+        overlap?: number;
+        strategy?: 'sentence' | 'paragraph' | 'fixed' | 'semantic';
+    }): string[];
+    /**
+     * Get existing chunks or create them if they don't exist
+     */
+    getChunks(): string[];
+    /**
+     * Set embeddings for the document or its chunks
+     *
+     * @param embeddings - Array of embedding vectors
+     */
+    setEmbeddings(embeddings: number[][]): void;
+    /**
+     * Get embeddings
+     */
+    getEmbeddings(): number[][] | undefined;
+    /**
+     * Convert to processed document format
+     */
+    toProcessedDocument(): ProcessedDocument;
+    /**
+     * Convert to plain object
+     */
+    toJSON(): DocumentConfig & {
+        chunks?: string[];
+        embeddings?: number[][];
+    };
+    /**
+     * Create MDocument from processed document
+     *
+     * @param processed - Processed document data
+     * @returns MDocument instance
+     */
+    static fromProcessedDocument(processed: ProcessedDocument): MDocument;
+    /**
+     * Extract text content based on document type
+     */
+    extractText(): string;
+    /**
+     * Count words in content
+     */
+    private countWords;
+    /**
+     * Fixed-size chunking with overlap
+     */
+    private chunkFixed;
+    /**
+     * Sentence-based chunking
+     */
+    private chunkBySentence;
+    /**
+     * Paragraph-based chunking
+     */
+    private chunkByParagraph;
+    /**
+     * Semantic chunking (basic implementation)
+     */
+    private chunkSemantic;
+    /**
+     * Extract text from markdown
+     */
+    private extractMarkdownText;
+    /**
+     * Extract text from JSON
+     */
+    private extractJSONText;
+    /**
+     * Extract text from XML
+     */
+    private extractXMLText;
+    /**
+     * Recursively extract text from object
+     */
+    private extractTextFromObject;
+}