@codebolt/agent 1.2.1 → 2.2.3

package/dist/processor-pieces/processors/chatCompressionProcessor.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompressionProcessor = void 0;
+const processor_1 = require("../../processor");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class ChatCompressionProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.compressionThreshold = options.compressionThreshold || 0.7;
+        this.compressionPreserveThreshold = options.compressionPreserveThreshold || 0.3;
+        this.tokenLimit = options.tokenLimit || 128000;
+        this.enableCompression = options.enableCompression !== false;
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            if (!this.enableCompression) {
+                return [this.createEvent('ChatCompressionDisabled', {
+                        reason: 'Compression is disabled for this session'
+                    })];
+            }
+            // Get chat history from CodeBolt
+            const chatHistory = await codeboltjs_1.default.chat.getChatHistory();
+            if (chatHistory.length === 0) {
+                return [this.createEvent('NoChatHistory', {
+                        reason: 'No chat history available for compression'
+                    })];
+            }
+            // Estimate token count (simple heuristic: 4 chars per token)
+            const estimatedTokens = this.estimateTokenCount(chatHistory);
+            const threshold = this.compressionThreshold * this.tokenLimit;
+            console.log(`[Compression] Estimated tokens: ${estimatedTokens}, threshold: ${threshold}`);
+            if (estimatedTokens < threshold) {
+                return [this.createEvent('ChatCompressionSkipped', {
+                        estimatedTokens,
+                        threshold,
+                        reason: 'Below compression threshold'
+                    })];
+            }
+            // Perform compression using CodeBolt's chatSummary
+            const compressionResult = await codeboltjs_1.default.chatSummary.summarizeAll();
+            if (compressionResult.success && compressionResult.data) {
+                const newTokenCount = this.estimateTokenCount(compressionResult.data);
+                const compressionInfo = {
+                    originalTokenCount: estimatedTokens,
+                    newTokenCount,
+                    compressionRatio: newTokenCount / estimatedTokens,
+                    threshold: this.compressionThreshold
+                };
+                // Send notification about compression
+                await codeboltjs_1.default.chat.sendNotificationEvent(`Chat compressed: ${estimatedTokens} → ${newTokenCount} tokens`, 'debug');
+                return [this.createEvent('ChatCompressed', compressionInfo)];
+            }
+            else {
+                return [this.createEvent('ChatCompressionFailed', {
+                        error: compressionResult.message || 'Unknown compression error',
+                        originalTokenCount: estimatedTokens
+                    })];
+            }
+        }
+        catch (error) {
+            console.error('Error in ChatCompressionProcessor:', error);
+            return [this.createEvent('ChatCompressionError', {
+                    error: error instanceof Error ? error.message : String(error)
+                })];
+        }
+    }
+    estimateTokenCount(data) {
+        // Simple heuristic: 4 characters per token
+        const totalContent = JSON.stringify(data);
+        return Math.ceil(totalContent.length / 4);
+    }
+    // Public methods for external control
+    setCompressionThreshold(threshold) {
+        this.compressionThreshold = Math.max(0.1, Math.min(0.9, threshold));
+    }
+    setTokenLimit(limit) {
+        this.tokenLimit = Math.max(1000, limit);
+    }
+    enableCompressionForSession() {
+        this.enableCompression = true;
+    }
+    disableCompressionForSession() {
+        this.enableCompression = false;
+    }
+}
+exports.ChatCompressionProcessor = ChatCompressionProcessor;

package/dist/processor-pieces/processors/chatRecordingProcessor.d.ts

@@ -0,0 +1,81 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface ChatRecordingProcessorOptions {
+    enableTokenTracking?: boolean;
+    exportFormat?: 'json' | 'txt' | 'csv';
+    outputDirectory?: string;
+    maxFileSize?: number;
+    enableCompression?: boolean;
+    includeMetadata?: boolean;
+    autoExport?: boolean;
+    exportInterval?: number;
+}
+export interface TokensSummary {
+    input: number;
+    output: number;
+    cached: number;
+    thoughts?: number;
+    tool?: number;
+    total: number;
+}
+export interface MessageRecord {
+    id: string;
+    timestamp: string;
+    role: string;
+    content: string;
+    metadata?: Record<string, any>;
+    tokens?: TokensSummary;
+    toolCalls?: ToolCallRecord[];
+}
+export interface ToolCallRecord {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    result?: any;
+    status: 'pending' | 'success' | 'error' | 'cancelled';
+    timestamp: string;
+    executionTime?: number;
+}
+export interface ConversationSession {
+    sessionId: string;
+    startTime: string;
+    endTime?: string;
+    messages: MessageRecord[];
+    totalTokens: TokensSummary;
+    toolCallCount: number;
+    metadata: Record<string, any>;
+}
+export declare class ChatRecordingProcessor extends BaseProcessor {
+    private readonly enableTokenTracking;
+    private readonly exportFormat;
+    private readonly outputDirectory;
+    private readonly maxFileSize;
+    private readonly enableCompression;
+    private readonly includeMetadata;
+    private readonly autoExport;
+    private readonly exportInterval;
+    private currentSession;
+    private messageCount;
+    private sessions;
+    constructor(options?: ChatRecordingProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private initializeSession;
+    private createMessageRecord;
+    private extractContent;
+    private extractToolCalls;
+    private estimateTokens;
+    private updateSessionTotals;
+    private generateSessionId;
+    private generateMessageId;
+    private generateToolCallId;
+    exportSession(session: ConversationSession): Promise<string>;
+    private ensureDirectoryExists;
+    private formatAsText;
+    private formatAsCSV;
+    finalizeSession(): Promise<string | null>;
+    getCurrentSession(): ConversationSession | null;
+    getSessionStats(): {
+        currentSessionMessages: number;
+        totalSessions: number;
+        totalMessages: number;
+    };
+}

package/dist/processor-pieces/processors/chatRecordingProcessor.js

@@ -0,0 +1,329 @@
+"use strict";
+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.ChatRecordingProcessor = void 0;
+const processor_1 = require("../../processor");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class ChatRecordingProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super();
+        // Session tracking
+        this.currentSession = null;
+        this.messageCount = 0;
+        this.sessions = [];
+        this.enableTokenTracking = options.enableTokenTracking !== false;
+        this.exportFormat = options.exportFormat || 'json';
+        this.outputDirectory = options.outputDirectory || './chat-recordings';
+        this.maxFileSize = options.maxFileSize || 10 * 1024 * 1024; // 10MB
+        this.enableCompression = options.enableCompression || false;
+        this.includeMetadata = options.includeMetadata !== false;
+        this.autoExport = options.autoExport || false;
+        this.exportInterval = options.exportInterval || 50;
+    }
+    async processInput(input) {
+        const { message, context } = input;
+        try {
+            // Initialize session if not exists
+            if (!this.currentSession) {
+                this.initializeSession(context);
+            }
+            // Record the message
+            const messageRecord = this.createMessageRecord(message, context);
+            this.currentSession.messages.push(messageRecord);
+            this.messageCount++;
+            // Update session totals
+            this.updateSessionTotals(messageRecord);
+            const results = [
+                this.createEvent('MessageRecorded', {
+                    messageId: messageRecord.id,
+                    sessionId: this.currentSession.sessionId,
+                    messageCount: this.messageCount
+                })
+            ];
+            // Auto-export if enabled and interval reached
+            if (this.autoExport && this.messageCount % this.exportInterval === 0) {
+                try {
+                    const exportPath = await this.exportSession(this.currentSession);
+                    results.push(this.createEvent('SessionExported', {
+                        sessionId: this.currentSession.sessionId,
+                        exportPath,
+                        messageCount: this.currentSession.messages.length
+                    }));
+                }
+                catch (exportError) {
+                    results.push(this.createEvent('ExportError', {
+                        error: exportError instanceof Error ? exportError.message : String(exportError),
+                        sessionId: this.currentSession.sessionId
+                    }));
+                }
+            }
+            return results;
+        }
+        catch (error) {
+            console.error('[ChatRecording] Error recording message:', error);
+            const messageStr = String(message);
+            return [this.createEvent('RecordingError', {
+                    error: error instanceof Error ? error.message : String(error),
+                    messageContent: messageStr.slice(0, 100)
+                })];
+        }
+    }
+    initializeSession(context) {
+        const sessionId = this.generateSessionId();
+        this.currentSession = {
+            sessionId,
+            startTime: new Date().toISOString(),
+            messages: [],
+            totalTokens: {
+                input: 0,
+                output: 0,
+                cached: 0,
+                total: 0
+            },
+            toolCallCount: 0,
+            metadata: {
+                llmConfig: (context === null || context === void 0 ? void 0 : context.llmconfig) || {},
+                userAgent: 'codebolt-agent',
+                version: '1.0.0',
+                ...context === null || context === void 0 ? void 0 : context.sessionMetadata
+            }
+        };
+    }
+    createMessageRecord(message, context) {
+        const id = this.generateMessageId();
+        const timestamp = new Date().toISOString();
+        // Extract basic message info
+        let role = 'unknown';
+        let content = '';
+        let toolCalls = [];
+        if (message.messages && Array.isArray(message.messages) && message.messages.length > 0) {
+            const lastMessage = message.messages[message.messages.length - 1];
+            role = lastMessage.role || 'unknown';
+            content = this.extractContent(lastMessage.content);
+            if (lastMessage.tool_calls) {
+                toolCalls = this.extractToolCalls(lastMessage.tool_calls);
+            }
+        }
+        else if (typeof message === 'string') {
+            role = 'user';
+            content = message;
+        }
+        else {
+            content = JSON.stringify(message);
+        }
+        // Calculate tokens if enabled
+        let tokens;
+        if (this.enableTokenTracking) {
+            tokens = this.estimateTokens(content);
+        }
+        return {
+            id,
+            timestamp,
+            role,
+            content: content.slice(0, 10000), // Limit content length for storage
+            metadata: this.includeMetadata ? {
+                originalMessageLength: content.length,
+                hasToolCalls: toolCalls.length > 0,
+                contextKeys: context ? Object.keys(context) : [],
+                ...message.metadata
+            } : undefined,
+            tokens,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+        };
+    }
+    extractContent(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            return content
+                .map(part => {
+                if (typeof part === 'string')
+                    return part;
+                if (part === null || part === void 0 ? void 0 : part.text)
+                    return part.text;
+                if ((part === null || part === void 0 ? void 0 : part.type) === 'text')
+                    return part.text || '';
+                return JSON.stringify(part);
+            })
+                .join(' ');
+        }
+        return JSON.stringify(content);
+    }
+    extractToolCalls(toolCalls) {
+        return toolCalls.map(tc => {
+            var _a, _b, _c;
+            return ({
+                id: tc.id || this.generateToolCallId(),
+                name: ((_a = tc.function) === null || _a === void 0 ? void 0 : _a.name) || 'unknown',
+                args: typeof ((_b = tc.function) === null || _b === void 0 ? void 0 : _b.arguments) === 'string'
+                    ? JSON.parse(tc.function.arguments)
+                    : ((_c = tc.function) === null || _c === void 0 ? void 0 : _c.arguments) || {},
+                status: 'pending',
+                timestamp: new Date().toISOString()
+            });
+        });
+    }
+    estimateTokens(content) {
+        // Simple token estimation
+        const charCount = content.length;
+        const estimated = Math.ceil(charCount / 4);
+        return {
+            input: estimated,
+            output: 0,
+            cached: 0,
+            total: estimated
+        };
+    }
+    updateSessionTotals(messageRecord) {
+        if (!this.currentSession || !messageRecord.tokens)
+            return;
+        this.currentSession.totalTokens.input += messageRecord.tokens.input;
+        this.currentSession.totalTokens.output += messageRecord.tokens.output;
+        this.currentSession.totalTokens.cached += messageRecord.tokens.cached;
+        this.currentSession.totalTokens.total += messageRecord.tokens.total;
+        if (messageRecord.toolCalls) {
+            this.currentSession.toolCallCount += messageRecord.toolCalls.length;
+        }
+    }
+    generateSessionId() {
+        return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    generateMessageId() {
+        return `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    generateToolCallId() {
+        return `tool-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
+    }
+    async exportSession(session) {
+        // Ensure output directory exists
+        await this.ensureDirectoryExists();
+        const filename = `chat-session-${session.sessionId}-${Date.now()}.${this.exportFormat}`;
+        const filepath = path.join(this.outputDirectory, filename);
+        // Update end time
+        session.endTime = new Date().toISOString();
+        let content;
+        switch (this.exportFormat) {
+            case 'json':
+                content = JSON.stringify(session, null, 2);
+                break;
+            case 'txt':
+                content = this.formatAsText(session);
+                break;
+            case 'csv':
+                content = this.formatAsCSV(session);
+                break;
+            default:
+                content = JSON.stringify(session, null, 2);
+        }
+        await fs.writeFile(filepath, content, 'utf-8');
+        return filepath;
+    }
+    async ensureDirectoryExists() {
+        try {
+            await fs.access(this.outputDirectory);
+        }
+        catch {
+            await fs.mkdir(this.outputDirectory, { recursive: true });
+        }
+    }
+    formatAsText(session) {
+        const lines = [];
+        lines.push(`Chat Session: ${session.sessionId}`);
+        lines.push(`Start Time: ${session.startTime}`);
+        lines.push(`End Time: ${session.endTime || 'Ongoing'}`);
+        lines.push(`Total Messages: ${session.messages.length}`);
+        lines.push(`Total Tokens: ${session.totalTokens.total}`);
+        lines.push(`Tool Calls: ${session.toolCallCount}`);
+        lines.push('---');
+        for (const message of session.messages) {
+            lines.push(`[${message.timestamp}] ${message.role.toUpperCase()}: ${message.content}`);
+            if (message.toolCalls) {
+                for (const tool of message.toolCalls) {
+                    lines.push(`  🔧 ${tool.name}(${JSON.stringify(tool.args)})`);
+                }
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    formatAsCSV(session) {
+        var _a, _b;
+        const headers = ['timestamp', 'role', 'content', 'tokens', 'tool_calls'];
+        const rows = [headers.join(',')];
+        for (const message of session.messages) {
+            const row = [
+                message.timestamp,
+                message.role,
+                `"${message.content.replace(/"/g, '""')}"`, // Escape quotes
+                ((_a = message.tokens) === null || _a === void 0 ? void 0 : _a.total) || 0,
+                ((_b = message.toolCalls) === null || _b === void 0 ? void 0 : _b.length) || 0
+            ];
+            rows.push(row.join(','));
+        }
+        return rows.join('\n');
+    }
+    // Public methods for session management
+    async finalizeSession() {
+        if (!this.currentSession)
+            return null;
+        try {
+            const exportPath = await this.exportSession(this.currentSession);
+            this.sessions.push(this.currentSession);
+            this.currentSession = null;
+            this.messageCount = 0;
+            return exportPath;
+        }
+        catch (error) {
+            console.error('[ChatRecording] Error finalizing session:', error);
+            return null;
+        }
+    }
+    getCurrentSession() {
+        return this.currentSession;
+    }
+    getSessionStats() {
+        var _a, _b;
+        const totalMessages = this.sessions.reduce((sum, session) => sum + session.messages.length, 0) +
+            (((_a = this.currentSession) === null || _a === void 0 ? void 0 : _a.messages.length) || 0);
+        return {
+            currentSessionMessages: ((_b = this.currentSession) === null || _b === void 0 ? void 0 : _b.messages.length) || 0,
+            totalSessions: this.sessions.length + (this.currentSession ? 1 : 0),
+            totalMessages
+        };
+    }
+}
+exports.ChatRecordingProcessor = ChatRecordingProcessor;

package/dist/processor-pieces/processors/contextManagementProcessor.d.ts

@@ -0,0 +1,40 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface ContextInfo {
+    projectContext?: string;
+    ideContext?: any;
+    directoryContext?: string;
+    contextAdded: boolean;
+}
+export interface ContextManagementProcessorOptions {
+    enableProjectContext?: boolean;
+    enableIdeContext?: boolean;
+    enableDirectoryContext?: boolean;
+    forceFullContext?: boolean;
+    contextThreshold?: number;
+}
+export declare class ContextManagementProcessor extends BaseProcessor {
+    private readonly enableProjectContext;
+    private readonly enableIdeContext;
+    private readonly enableDirectoryContext;
+    private readonly forceFullContext;
+    private readonly contextThreshold;
+    private lastSentIdeContext;
+    private contextAddedToHistory;
+    constructor(options?: ContextManagementProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private collectContext;
+    private getProjectContext;
+    private getIdeContext;
+    private getDirectoryContext;
+    private detectIdeType;
+    private getOpenFiles;
+    private getActiveFile;
+    private addContextToMessage;
+    resetContext(): void;
+    forceContextRefresh(): void;
+    setContextThreshold(threshold: number): void;
+    enableProjectContextForSession(): void;
+    disableProjectContextForSession(): void;
+    enableIdeContextForSession(): void;
+    disableIdeContextForSession(): void;
+}