@codebolt/agent 2.2.2 → 2.2.5

package/dist/processor-pieces/postToolCall/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/postToolCall/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;
+}

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

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

@@ -0,0 +1,49 @@
+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;
+}