@codebolt/agent 1.2.1 → 2.2.3

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

@@ -0,0 +1,305 @@
+"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;
+    };
+})();
+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 Promise.resolve().then(() => __importStar(require('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 Promise.resolve().then(() => __importStar(require('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/processors/loopDetectionProcessor.d.ts

@@ -0,0 +1,30 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface LoopDetectionInfo {
+    promptId: string;
+    loopCount: number;
+    maxLoops: number;
+    recentMessages: any[];
+    isLoop: boolean;
+}
+export interface LoopDetectionProcessorOptions {
+    maxLoops?: number;
+    messageThreshold?: number;
+    enableLoopDetection?: boolean;
+}
+export declare class LoopDetectionProcessor extends BaseProcessor {
+    private readonly maxLoops;
+    private readonly messageThreshold;
+    private readonly enableLoopDetection;
+    private lastPromptId;
+    private loopCount;
+    constructor(options?: LoopDetectionProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private generatePromptId;
+    private resetLoopDetector;
+    private checkLoopDetection;
+    resetSession(): void;
+    getCurrentLoopCount(): number;
+    setMaxLoops(maxLoops: number): void;
+    enableLoopDetectionForSession(): void;
+    disableLoopDetectionForSession(): void;
+}

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

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetectionProcessor = void 0;
+const processor_1 = require("../../processor");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class LoopDetectionProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.lastPromptId = null;
+        this.loopCount = 0;
+        this.maxLoops = options.maxLoops || 3;
+        this.messageThreshold = options.messageThreshold || 6;
+        this.enableLoopDetection = options.enableLoopDetection !== false;
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            if (!this.enableLoopDetection) {
+                return [this.createEvent('LoopDetectionDisabled', {
+                        reason: 'Loop detection is disabled for this session'
+                    })];
+            }
+            // Get prompt ID from context or generate one
+            const promptId = (context === null || context === void 0 ? void 0 : context.promptId) || this.generatePromptId();
+            // Reset loop detector if new prompt
+            if (this.lastPromptId !== promptId) {
+                await this.resetLoopDetector(promptId);
+                this.lastPromptId = promptId;
+            }
+            else {
+                this.loopCount++;
+            }
+            // Check for conversation loops using CodeBolt state
+            const loopDetected = await this.checkLoopDetection();
+            if (loopDetected) {
+                // Send notification about loop detection
+                await codeboltjs_1.default.chat.sendNotificationEvent('Loop detected in conversation', 'debug');
+                return [this.createEvent('LoopDetected', {
+                        promptId,
+                        loopCount: this.loopCount,
+                        maxLoops: this.maxLoops
+                    })];
+            }
+            // Check if max loops reached
+            if (this.loopCount > this.maxLoops) {
+                return [this.createEvent('MaxLoopsReached', {
+                        promptId,
+                        loopCount: this.loopCount,
+                        maxLoops: this.maxLoops
+                    })];
+            }
+            // Continue processing
+            return [this.createEvent('LoopDetectionPassed', {
+                    promptId,
+                    loopCount: this.loopCount,
+                    maxLoops: this.maxLoops
+                })];
+        }
+        catch (error) {
+            console.error('Error in LoopDetectionProcessor:', error);
+            return [this.createEvent('LoopDetectionError', {
+                    error: error instanceof Error ? error.message : String(error)
+                })];
+        }
+    }
+    generatePromptId() {
+        return `prompt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    async resetLoopDetector(promptId) {
+        this.loopCount = 0;
+        this.setContext('currentPromptId', promptId);
+        this.setContext('loopDetectorReset', Date.now().toString());
+        // Update CodeBolt agent state
+        try {
+            await codeboltjs_1.default.cbstate.addToAgentState('lastPromptId', promptId);
+            await codeboltjs_1.default.cbstate.addToAgentState('loopDetectorReset', Date.now().toString());
+        }
+        catch (error) {
+            console.warn('Failed to update CodeBolt agent state:', error);
+        }
+    }
+    async checkLoopDetection() {
+        var _a;
+        try {
+            // Get recent messages from CodeBolt state
+            const agentState = await codeboltjs_1.default.cbstate.getAgentState();
+            const recentMessages = ((_a = agentState.data) === null || _a === void 0 ? void 0 : _a.recentMessages) || [];
+            // Simple loop detection: check for repeated patterns
+            if (recentMessages.length >= this.messageThreshold) {
+                const lastThree = recentMessages.slice(-3);
+                const previousThree = recentMessages.slice(-6, -3);
+                if (lastThree.length === 3 && previousThree.length === 3) {
+                    const isLoop = JSON.stringify(lastThree) === JSON.stringify(previousThree);
+                    if (isLoop) {
+                        console.log('[Loop Detection] Loop detected in conversation');
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        catch (error) {
+            console.warn('Failed to check loop detection:', error);
+            return false;
+        }
+    }
+    // Public methods for external control
+    resetSession() {
+        this.loopCount = 0;
+        this.lastPromptId = null;
+        this.clearContext();
+        // Clear CodeBolt agent state
+        try {
+            codeboltjs_1.default.cbstate.addToAgentState('sessionTurnCount', '0');
+            codeboltjs_1.default.cbstate.addToAgentState('lastPromptId', '');
+        }
+        catch (error) {
+            console.warn('Failed to clear CodeBolt agent state:', error);
+        }
+    }
+    getCurrentLoopCount() {
+        return this.loopCount;
+    }
+    setMaxLoops(maxLoops) {
+        this.maxLoops = Math.max(1, maxLoops);
+    }
+    enableLoopDetectionForSession() {
+        this.enableLoopDetection = true;
+    }
+    disableLoopDetectionForSession() {
+        this.enableLoopDetection = false;
+    }
+}
+exports.LoopDetectionProcessor = LoopDetectionProcessor;

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

@@ -0,0 +1,30 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface ResponseValidationProcessorOptions {
+    validateToolCalls?: boolean;
+    validateContent?: boolean;
+    validateStructure?: boolean;
+    allowEmptyContent?: boolean;
+    maxContentLength?: number;
+    requiredFields?: string[];
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    fixes: string[];
+}
+export declare class ResponseValidationProcessor extends BaseProcessor {
+    private readonly enableToolCallValidation;
+    private readonly validateContent;
+    private readonly validateStructure;
+    private readonly allowEmptyContent;
+    private readonly maxContentLength;
+    private readonly requiredFields;
+    constructor(options?: ResponseValidationProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private validateMessage;
+    private validateMessageStructure;
+    private validateMessageContent;
+    private validateToolCallsInMessage;
+    getValidationSummary(validationResult: ValidationResult): string;
+}