@codebolt/agent 5.0.2 → 5.0.6

package/dist/processor-pieces/postToolCall/contextManagementProcessor.js

@@ -1,272 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextManagementProcessor = void 0;
-const processor_1 = require("../../processor");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-class ContextManagementProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.lastSentIdeContext = undefined;
-        this.contextAddedToHistory = false;
-        this.enableProjectContext = options.enableProjectContext !== false;
-        this.enableIdeContext = options.enableIdeContext !== false;
-        this.enableDirectoryContext = options.enableDirectoryContext !== false;
-        this.forceFullContext = options.forceFullContext || false;
-        this.contextThreshold = options.contextThreshold || 100;
-    }
-    async processInput(input) {
-        try {
-            const { message, context } = input;
-            // Check if context should be added
-            if (this.contextAddedToHistory && !this.forceFullContext) {
-                return [this.createEvent('ContextAlreadyAdded', {
-                        reason: 'Context has already been added to this session'
-                    })];
-            }
-            // Collect context information using CodeBolt
-            const contextInfo = await this.collectContext();
-            if (!contextInfo.contextAdded) {
-                return [this.createEvent('NoContextAvailable', {
-                        reason: 'No relevant context found for this session'
-                    })];
-            }
-            // Add context to the message
-            const messageWithContext = await this.addContextToMessage(message, contextInfo);
-            // Mark context as added
-            this.contextAddedToHistory = true;
-            return [
-                this.createEvent('ContextAdded', contextInfo),
-                this.createEvent('MessageWithContext', messageWithContext)
-            ];
-        }
-        catch (error) {
-            console.error('Error in ContextManagementProcessor:', error);
-            return [this.createEvent('ContextError', {
-                    error: error instanceof Error ? error.message : String(error)
-                })];
-        }
-    }
-    async collectContext() {
-        const contextInfo = {
-            contextAdded: false
-        };
-        try {
-            // Collect project context if enabled
-            if (this.enableProjectContext) {
-                contextInfo.projectContext = await this.getProjectContext();
-            }
-            // Collect IDE context if enabled
-            if (this.enableIdeContext) {
-                contextInfo.ideContext = await this.getIdeContext();
-            }
-            // Collect directory context if enabled
-            if (this.enableDirectoryContext) {
-                contextInfo.directoryContext = await this.getDirectoryContext();
-            }
-            // Check if we have any meaningful context
-            contextInfo.contextAdded = !!(contextInfo.projectContext || contextInfo.ideContext || contextInfo.directoryContext);
-        }
-        catch (error) {
-            console.warn('Failed to collect context:', error);
-        }
-        return contextInfo;
-    }
-    async getProjectContext() {
-        try {
-            // Get current working directory and project info
-            const cwd = process.cwd();
-            const projectName = cwd.split(/[\\/]/).pop() || 'unknown-project';
-            // Try to get additional project info from CodeBolt if available
-            let additionalInfo = '';
-            try {
-                const projectPath = await codeboltjs_1.default.project.getProjectPath();
-                if (projectPath.success && projectPath.data) {
-                    additionalInfo = `\nProject Path: ${projectPath.data}`;
-                }
-            }
-            catch (error) {
-                // Project info is optional
-            }
-            return `Project: ${projectName}\nWorking Directory: ${cwd}${additionalInfo}`;
-        }
-        catch (error) {
-            console.warn('Failed to get project context:', error);
-            return undefined;
-        }
-    }
-    async getIdeContext() {
-        try {
-            // This would normally integrate with CodeBolt's IDE context detection
-            // For now, simulate basic IDE context
-            const ideContext = {
-                ideType: this.detectIdeType(),
-                openFiles: await this.getOpenFiles(),
-                activeFile: await this.getActiveFile()
-            };
-            // Update last sent IDE context
-            this.lastSentIdeContext = ideContext;
-            return ideContext;
-        }
-        catch (error) {
-            console.warn('Failed to get IDE context:', error);
-            return undefined;
-        }
-    }
-    async getDirectoryContext() {
-        try {
-            // Get directory structure using CodeBolt's file system capabilities
-            const cwd = process.cwd();
-            // Try to get directory listing from CodeBolt
-            let directoryContents = '';
-            try {
-                const listResult = await codeboltjs_1.default.fs.listFile(cwd);
-                if (listResult.success && listResult.data) {
-                    const items = listResult.data.filter((item) => !item.name.startsWith('.'));
-                    directoryContents = items.slice(0, 10).map((item) => item.name).join(', ');
-                    if (items.length > 10) {
-                        directoryContents += '...';
-                    }
-                }
-            }
-            catch (error) {
-                // Fallback to basic directory listing
-                const fs = await import('fs/promises');
-                const items = await fs.readdir(cwd);
-                const files = items.filter(item => !item.startsWith('.'));
-                directoryContents = files.slice(0, 10).join(', ') + (files.length > 10 ? '...' : '');
-            }
-            return `Directory: ${cwd}\nContents: ${directoryContents}`;
-        }
-        catch (error) {
-            console.warn('Failed to get directory context:', error);
-            return undefined;
-        }
-    }
-    detectIdeType() {
-        // Detect IDE type from environment variables
-        if (process.env.VSCODE_PID || process.env.VSCODE_IPC_HOOK) {
-            return 'vscode';
-        }
-        if (process.env.CURSOR_PID || process.env.CURSOR_SESSION_ID) {
-            return 'cursor';
-        }
-        return 'unknown';
-    }
-    async getOpenFiles() {
-        try {
-            // This would normally get actual open files from IDE
-            // For now, simulate with recent files in current directory
-            const cwd = process.cwd();
-            // Try to get recent files from CodeBolt
-            let files = [];
-            try {
-                // CodeBolt doesn't have findRecentFiles, so we'll use listFile as fallback
-                const listResult = await codeboltjs_1.default.fs.listFile(cwd);
-                if (listResult.success && listResult.data) {
-                    const fileItems = listResult.data.filter((item) => !item.name.startsWith('.') && item.includes('.'));
-                    files = fileItems.slice(0, 5).map((file, index) => ({
-                        path: file.name,
-                        isActive: index === 0,
-                        timestamp: Date.now()
-                    }));
-                }
-            }
-            catch (error) {
-                // Fallback to basic file listing
-                const fs = await import('fs/promises');
-                const items = await fs.readdir(cwd);
-                const fileItems = items.filter(item => !item.startsWith('.') && item.includes('.'));
-                files = fileItems.slice(0, 5).map((file, index) => ({
-                    path: file,
-                    isActive: index === 0,
-                    timestamp: Date.now()
-                }));
-            }
-            return files;
-        }
-        catch (error) {
-            return [];
-        }
-    }
-    async getActiveFile() {
-        try {
-            const openFiles = await this.getOpenFiles();
-            return openFiles.find(f => f.isActive);
-        }
-        catch (error) {
-            return undefined;
-        }
-    }
-    async addContextToMessage(message, contextInfo) {
-        const contextMessages = [];
-        // Add project context
-        if (contextInfo.projectContext) {
-            contextMessages.push({
-                role: 'system',
-                content: `Project Context:\n${contextInfo.projectContext}`,
-                name: 'project-context'
-            });
-        }
-        // Add IDE context
-        if (contextInfo.ideContext) {
-            contextMessages.push({
-                role: 'system',
-                content: `IDE Context:\n\`\`\`json\n${JSON.stringify(contextInfo.ideContext, null, 2)}\n\`\`\``,
-                name: 'ide-context'
-            });
-        }
-        // Add directory context
-        if (contextInfo.directoryContext) {
-            contextMessages.push({
-                role: 'system',
-                content: `Directory Context:\n${contextInfo.directoryContext}`,
-                name: 'directory-context'
-            });
-        }
-        // Add acknowledgment message
-        if (contextMessages.length > 0) {
-            contextMessages.push({
-                role: 'assistant',
-                content: 'Got it. Thanks for the context!',
-                name: 'context-acknowledgment'
-            });
-        }
-        return {
-            messages: [...contextMessages, ...message.messages],
-            metadata: {
-                ...message.metadata,
-                contextAdded: true,
-                contextInfo
-            }
-        };
-    }
-    // Public methods for external control
-    resetContext() {
-        this.contextAddedToHistory = false;
-        this.lastSentIdeContext = undefined;
-        this.clearContext();
-    }
-    forceContextRefresh() {
-        this.forceFullContext = true;
-        this.contextAddedToHistory = false;
-    }
-    setContextThreshold(threshold) {
-        this.contextThreshold = Math.max(1, threshold);
-    }
-    enableProjectContextForSession() {
-        this.enableProjectContext = true;
-    }
-    disableProjectContextForSession() {
-        this.enableProjectContext = false;
-    }
-    enableIdeContextForSession() {
-        this.enableIdeContext = true;
-    }
-    disableIdeContextForSession() {
-        this.enableIdeContext = false;
-    }
-}
-exports.ContextManagementProcessor = ContextManagementProcessor;

package/dist/processor-pieces/postToolCall/conversationCompactorProcessor.d.ts

@@ -1,49 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface ConversationCompactorInfo {
-    originalMessageCount: number;
-    compactedMessageCount: number;
-    compressionRatio: number;
-    compactionMethod: 'summarization' | 'truncation' | 'smart_removal';
-    preservedMessages: number;
-    removedMessages: number;
-}
-export interface ConversationCompactorProcessorOptions {
-    maxConversationLength?: number;
-    compactionThreshold?: number;
-    preserveRecentMessages?: number;
-    preserveSystemMessages?: boolean;
-    preserveToolMessages?: boolean;
-    enableSummarization?: boolean;
-    enableSmartRemoval?: boolean;
-    compressionRatio?: number;
-}
-/**
- * Processor that compacts long conversations to keep them within manageable limits
- * while preserving important context and recent interactions.
- */
-export declare class ConversationCompactorProcessor extends BaseProcessor {
-    private readonly maxConversationLength;
-    private readonly compactionThreshold;
-    private readonly preserveRecentMessages;
-    private readonly preserveSystemMessages;
-    private readonly preserveToolMessages;
-    private readonly enableSummarization;
-    private readonly enableSmartRemoval;
-    private readonly compressionRatio;
-    constructor(options?: ConversationCompactorProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private compactConversation;
-    private performSmartRemoval;
-    private selectImportantMessages;
-    private calculateMessageImportance;
-    private performSummarization;
-    private performTruncation;
-    private calculateCompactionInfo;
-    setMaxConversationLength(length: number): void;
-    setCompressionRatio(ratio: number): void;
-    setPreserveRecentMessages(count: number): void;
-    enableSummarizationForSession(): void;
-    disableSummarizationForSession(): void;
-    enableSmartRemovalForSession(): void;
-    disableSmartRemovalForSession(): void;
-}

package/dist/processor-pieces/postToolCall/conversationCompactorProcessor.js

@@ -1,291 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationCompactorProcessor = void 0;
-const processor_1 = require("../../processor");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-const { chatSummary } = codeboltjs_1.default;
-/**
- * Processor that compacts long conversations to keep them within manageable limits
- * while preserving important context and recent interactions.
- */
-class ConversationCompactorProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.maxConversationLength = options.maxConversationLength || 50;
-        this.compactionThreshold = options.compactionThreshold || 0.8; // Compact when 80% of max length
-        this.preserveRecentMessages = options.preserveRecentMessages || 10;
-        this.preserveSystemMessages = options.preserveSystemMessages !== false;
-        this.preserveToolMessages = options.preserveToolMessages !== false;
-        this.enableSummarization = options.enableSummarization !== false;
-        this.enableSmartRemoval = options.enableSmartRemoval !== false;
-        this.compressionRatio = options.compressionRatio || 0.6; // Target 60% of original size
-    }
-    async processInput(input) {
-        try {
-            const { message, context } = input;
-            const conversationLength = message.messages.length;
-            const threshold = Math.floor(this.maxConversationLength * this.compactionThreshold);
-            // Check if compaction is needed
-            if (conversationLength <= threshold) {
-                return [this.createEvent('ConversationCompactionSkipped', {
-                        conversationLength,
-                        threshold,
-                        reason: 'Below compaction threshold'
-                    })];
-            }
-            // Perform compaction
-            const compactedMessage = await this.compactConversation(message, context);
-            const compactionInfo = this.calculateCompactionInfo(message, compactedMessage);
-            return [
-                this.createEvent('ConversationCompacted', compactionInfo),
-                this.createEvent('ConversationProcessed', compactedMessage)
-            ];
-        }
-        catch (error) {
-            console.error('Error in ConversationCompactorProcessor:', error);
-            return [this.createEvent('ConversationCompactionError', {
-                    error: error instanceof Error ? error.message : String(error),
-                    originalLength: input.message.messages.length
-                })];
-        }
-    }
-    async compactConversation(message, context) {
-        const messages = [...message.messages];
-        let compactionMethod = 'truncation';
-        // Try smart removal first if enabled
-        if (this.enableSmartRemoval) {
-            const smartCompacted = await this.performSmartRemoval(messages);
-            if (smartCompacted.length <= this.maxConversationLength) {
-                compactionMethod = 'smart_removal';
-                return {
-                    ...message,
-                    messages: smartCompacted,
-                    metadata: {
-                        ...message.metadata,
-                        compacted: true,
-                        compactionMethod,
-                        originalLength: messages.length,
-                        compactedLength: smartCompacted.length
-                    }
-                };
-            }
-        }
-        // Try summarization if enabled and we have chat summary service
-        if (this.enableSummarization) {
-            try {
-                const summarized = await this.performSummarization(messages);
-                if (summarized.length <= this.maxConversationLength) {
-                    compactionMethod = 'summarization';
-                    return {
-                        ...message,
-                        messages: summarized,
-                        metadata: {
-                            ...message.metadata,
-                            compacted: true,
-                            compactionMethod,
-                            originalLength: messages.length,
-                            compactedLength: summarized.length
-                        }
-                    };
-                }
-            }
-            catch (error) {
-                console.warn('Summarization failed, falling back to truncation:', error);
-            }
-        }
-        // Fall back to truncation
-        const truncated = this.performTruncation(messages);
-        return {
-            ...message,
-            messages: truncated,
-            metadata: {
-                ...message.metadata,
-                compacted: true,
-                compactionMethod,
-                originalLength: messages.length,
-                compactedLength: truncated.length
-            }
-        };
-    }
-    async performSmartRemoval(messages) {
-        const result = [];
-        const messagesToAnalyze = [...messages];
-        // Always preserve system messages if enabled
-        if (this.preserveSystemMessages) {
-            const systemMessages = messagesToAnalyze.filter(m => m.role === 'system');
-            result.push(...systemMessages);
-            messagesToAnalyze.splice(0, messagesToAnalyze.length, ...messagesToAnalyze.filter(m => m.role !== 'system'));
-        }
-        // Always preserve recent messages
-        const recentMessages = messagesToAnalyze.slice(-this.preserveRecentMessages);
-        const olderMessages = messagesToAnalyze.slice(0, -this.preserveRecentMessages);
-        // Analyze older messages for importance
-        const importantOlderMessages = this.selectImportantMessages(olderMessages);
-        // Preserve tool messages if enabled
-        let toolMessages = [];
-        if (this.preserveToolMessages) {
-            toolMessages = olderMessages.filter(m => m.role === 'tool');
-        }
-        // Combine all preserved messages
-        const preservedMessages = [
-            ...importantOlderMessages,
-            ...toolMessages,
-            ...recentMessages
-        ];
-        // Remove duplicates while preserving order
-        const seen = new Set();
-        const uniqueMessages = preservedMessages.filter(msg => {
-            const key = `${msg.role}-${JSON.stringify(msg.content)}-${msg.tool_call_id || ''}`;
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
-        result.push(...uniqueMessages);
-        return result;
-    }
-    selectImportantMessages(messages) {
-        // Score messages based on importance criteria
-        const scoredMessages = messages.map(msg => ({
-            message: msg,
-            score: this.calculateMessageImportance(msg)
-        }));
-        // Sort by score (highest first)
-        scoredMessages.sort((a, b) => b.score - a.score);
-        // Select top messages up to compression ratio
-        const targetCount = Math.floor(messages.length * this.compressionRatio);
-        return scoredMessages.slice(0, targetCount).map(sm => sm.message);
-    }
-    calculateMessageImportance(message) {
-        let score = 0;
-        // Base score by role
-        switch (message.role) {
-            case 'system':
-                score += 10;
-                break;
-            case 'tool':
-                score += 8;
-                break;
-            case 'assistant':
-                score += 5;
-                break;
-            case 'user':
-                score += 3;
-                break;
-        }
-        // Content-based scoring
-        const content = typeof message.content === 'string'
-            ? message.content
-            : JSON.stringify(message.content);
-        // Longer messages might be more important
-        score += Math.min(content.length / 100, 5);
-        // Messages with tool calls are important
-        if (message.tool_calls && message.tool_calls.length > 0) {
-            score += 7;
-        }
-        // Messages with specific keywords are important
-        const importantKeywords = [
-            'error', 'warning', 'critical', 'important', 'required',
-            'configuration', 'setup', 'install', 'deploy', 'build'
-        ];
-        const lowerContent = content.toLowerCase();
-        importantKeywords.forEach(keyword => {
-            if (lowerContent.includes(keyword)) {
-                score += 2;
-            }
-        });
-        return score;
-    }
-    async performSummarization(messages) {
-        try {
-            // Preserve system messages and recent messages
-            const systemMessages = this.preserveSystemMessages
-                ? messages.filter(m => m.role === 'system')
-                : [];
-            const recentMessages = messages.slice(-this.preserveRecentMessages);
-            const messagesToSummarize = messages.slice(0, -this.preserveRecentMessages)
-                .filter(m => !this.preserveSystemMessages || m.role !== 'system');
-            if (messagesToSummarize.length === 0) {
-                return [...systemMessages, ...recentMessages];
-            }
-            // Convert to format expected by chatSummary
-            const formattedMessages = messagesToSummarize.map(msg => ({
-                role: msg.role,
-                content: typeof msg.content === 'string' ? msg.content :
-                    Array.isArray(msg.content) ? msg.content.map(c => c.text).join(' ') :
-                        JSON.stringify(msg.content)
-            }));
-            // Use chat summary service
-            const targetLength = Math.floor(this.maxConversationLength * this.compressionRatio);
-            const summaryResponse = await chatSummary.summarize(formattedMessages, targetLength);
-            if (summaryResponse && (summaryResponse.payload || summaryResponse.summary)) {
-                const summaryText = summaryResponse.payload || summaryResponse.summary;
-                const summaryMessage = {
-                    role: 'system',
-                    content: `Previous conversation summary: ${summaryText}`,
-                    name: 'conversation-summary'
-                };
-                return [
-                    ...systemMessages,
-                    summaryMessage,
-                    ...recentMessages
-                ];
-            }
-            // If summarization fails, fall back to truncation
-            return this.performTruncation(messages);
-        }
-        catch (error) {
-            console.warn('Summarization failed:', error);
-            return this.performTruncation(messages);
-        }
-    }
-    performTruncation(messages) {
-        // Simple truncation: keep system messages + recent messages
-        const systemMessages = this.preserveSystemMessages
-            ? messages.filter(m => m.role === 'system')
-            : [];
-        const nonSystemMessages = messages.filter(m => !this.preserveSystemMessages || m.role !== 'system');
-        const availableSlots = this.maxConversationLength - systemMessages.length;
-        const recentMessages = nonSystemMessages.slice(-Math.max(availableSlots, this.preserveRecentMessages));
-        return [...systemMessages, ...recentMessages];
-    }
-    calculateCompactionInfo(original, compacted) {
-        var _a;
-        const originalCount = original.messages.length;
-        const compactedCount = compacted.messages.length;
-        return {
-            originalMessageCount: originalCount,
-            compactedMessageCount: compactedCount,
-            compressionRatio: compactedCount / originalCount,
-            compactionMethod: ((_a = compacted.metadata) === null || _a === void 0 ? void 0 : _a.compactionMethod) || 'truncation',
-            preservedMessages: compactedCount,
-            removedMessages: originalCount - compactedCount
-        };
-    }
-    // Public methods for configuration
-    setMaxConversationLength(length) {
-        this.maxConversationLength = Math.max(10, length);
-    }
-    setCompressionRatio(ratio) {
-        this.compressionRatio = Math.max(0.1, Math.min(0.9, ratio));
-    }
-    setPreserveRecentMessages(count) {
-        this.preserveRecentMessages = Math.max(1, count);
-    }
-    enableSummarizationForSession() {
-        this.enableSummarization = true;
-    }
-    disableSummarizationForSession() {
-        this.enableSummarization = false;
-    }
-    enableSmartRemovalForSession() {
-        this.enableSmartRemoval = true;
-    }
-    disableSmartRemovalForSession() {
-        this.enableSmartRemoval = false;
-    }
-}
-exports.ConversationCompactorProcessor = ConversationCompactorProcessor;

package/dist/processor-pieces/postToolCall/conversationContinuityProcessor.d.ts

@@ -1,49 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface ConversationContinuityInfo {
-    contextLinksAdded: number;
-    referenceResolutionsAdded: number;
-    continuityEnhanced: boolean;
-    missingContextDetected: boolean;
-    conversationGapsFound: number;
-}
-export interface ConversationContinuityProcessorOptions {
-    enableContextLinking?: boolean;
-    enableReferenceResolution?: boolean;
-    enableGapDetection?: boolean;
-    maxContextLinks?: number;
-    contextLookbackWindow?: number;
-    enableProactiveContext?: boolean;
-}
-/**
- * Processor that maintains conversation continuity by linking related messages,
- * resolving references, and detecting context gaps in follow-up conversations.
- */
-export declare class ConversationContinuityProcessor extends BaseProcessor {
-    private readonly enableContextLinking;
-    private readonly enableReferenceResolution;
-    private readonly enableGapDetection;
-    private readonly maxContextLinks;
-    private readonly contextLookbackWindow;
-    private readonly enableProactiveContext;
-    constructor(options?: ConversationContinuityProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private enhanceConversationContinuity;
-    private addContextLinks;
-    private findReferencingMessages;
-    private generateContextLinkMessage;
-    private resolveReferences;
-    private resolveMessageReferences;
-    private detectAndFillGaps;
-    private detectConversationGaps;
-    private generateGapFillerMessage;
-    private addProactiveContext;
-    private calculateContinuityInfo;
-    setContextLookbackWindow(window: number): void;
-    setMaxContextLinks(max: number): void;
-    enableContextLinkingForSession(): void;
-    disableContextLinkingForSession(): void;
-    enableReferenceResolutionForSession(): void;
-    disableReferenceResolutionForSession(): void;
-    enableGapDetectionForSession(): void;
-    disableGapDetectionForSession(): void;
-}