@codebolt/agent 5.0.2 → 5.0.7

package/dist/processor-pieces/additionalModifiers/environmentContextModifier.js

@@ -1,269 +0,0 @@
-"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.EnvironmentContextModifier = void 0;
-const base_1 = require("../base");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-class EnvironmentContextModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.defaultExcludePatterns = [
-            'node_modules/**',
-            '.git/**',
-            'dist/**',
-            'build/**',
-            '*.log',
-            '*.tmp',
-            '.DS_Store',
-            'coverage/**',
-            '.next/**',
-            '.nuxt/**'
-        ];
-        this.options = {
-            enableFullContext: options.enableFullContext || false,
-            maxFiles: options.maxFiles || 100,
-            maxFileSize: options.maxFileSize || 100 * 1024, // 100KB per file
-            includePatterns: options.includePatterns || ['**/*.ts', '**/*.js', '**/*.json', '**/*.md', '**/*.txt', '**/*.yml', '**/*.yaml'],
-            excludePatterns: [...this.defaultExcludePatterns, ...(options.excludePatterns || [])]
-        };
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            // Get current date formatted to user's locale
-            const today = new Date().toLocaleDateString(undefined, {
-                weekday: 'long',
-                year: 'numeric',
-                month: 'long',
-                day: 'numeric',
-            });
-            const platform = process.platform;
-            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
-            if (!projectPath) {
-                return createdMessage;
-            }
-            const currentDir = projectPath;
-            // Get basic directory listing
-            let directoryListing = '';
-            try {
-                const files = await fs.promises.readdir(currentDir);
-                const fileList = files.slice(0, 20).join(', '); // Limit to first 20 files
-                const moreFiles = files.length > 20 ? ` ... and ${files.length - 20} more files` : '';
-                directoryListing = `Files in current directory: ${fileList}${moreFiles}`;
-            }
-            catch (error) {
-                directoryListing = 'Unable to read current directory';
-            }
-            const environmentContext = `
-This is the CodeBolt AI Agent. Setting up context for our chat.
-Today's date is ${today} (formatted according to the user's locale).
-Operating system: ${platform}
-Current working directory: ${currentDir}
-${directoryListing}
-            `.trim();
-            // Prepare context parts (same as gemini-cli)
-            const contextParts = [environmentContext];
-            // Add full file context if enabled (just like gemini-cli does)
-            if (this.options.enableFullContext) {
-                try {
-                    const fullContextContent = await this.generateFullContext(currentDir);
-                    if (fullContextContent) {
-                        contextParts.push(`\n--- Full File Context ---\n${fullContextContent}`);
-                    }
-                }
-                catch (error) {
-                    console.error('Error reading full file context:', error);
-                    contextParts.push('\n--- Error reading full file context ---');
-                }
-            }
-            const finalContent = contextParts.join('\n\n');
-            const contextMessage = {
-                role: 'system',
-                content: finalContent
-            };
-            // Find existing system message or add new one
-            const messages = [...createdMessage.message.messages];
-            const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
-            if (systemMessageIndex !== -1) {
-                // Append to existing system message
-                messages[systemMessageIndex] = {
-                    ...messages[systemMessageIndex],
-                    content: `${messages[systemMessageIndex].content}\n\n${finalContent}`
-                };
-            }
-            else {
-                // Add new system message at the beginning
-                messages.unshift(contextMessage);
-            }
-            return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
-                metadata: {
-                    ...createdMessage.metadata,
-                    environmentContextAdded: true,
-                    fullContextAdded: this.options.enableFullContext,
-                    contextFilesCount: this.options.enableFullContext ? await this.countContextFiles(currentDir) : 0,
-                    environmentInfo: {
-                        date: today,
-                        platform,
-                        currentDir
-                    }
-                }
-            });
-        }
-        catch (error) {
-            console.error('Error in EnvironmentContextModifier:', error);
-            return createdMessage;
-        }
-    }
-    // Full context methods (integrated like gemini-cli)
-    async generateFullContext(basePath) {
-        try {
-            const files = await this.findRelevantFiles(basePath);
-            const contextParts = [];
-            let processedFiles = 0;
-            for (const filePath of files) {
-                if (processedFiles >= this.options.maxFiles) {
-                    contextParts.push(`\n... (${files.length - processedFiles} more files not shown due to limit)\n`);
-                    break;
-                }
-                try {
-                    const relativePath = path.relative(basePath, filePath);
-                    const stats = await fs.promises.stat(filePath);
-                    // Skip files that are too large
-                    if (stats.size > this.options.maxFileSize) {
-                        contextParts.push(`--- ${relativePath} ---\n[File too large: ${stats.size} bytes]\n`);
-                        processedFiles++;
-                        continue;
-                    }
-                    const content = await fs.promises.readFile(filePath, 'utf-8');
-                    contextParts.push(`--- ${relativePath} ---\n${content}\n`);
-                    processedFiles++;
-                }
-                catch (error) {
-                    const relativePath = path.relative(basePath, filePath);
-                    contextParts.push(`--- ${relativePath} ---\n[Error reading file: ${error instanceof Error ? error.message : 'Unknown error'}]\n`);
-                    processedFiles++;
-                }
-            }
-            return contextParts.join('\n');
-        }
-        catch (error) {
-            console.error('Error generating full context:', error);
-            return '';
-        }
-    }
-    async findRelevantFiles(basePath) {
-        const files = [];
-        try {
-            await this.walkDirectory(basePath, files, basePath);
-            return files.sort();
-        }
-        catch (error) {
-            console.error('Error finding relevant files:', error);
-            return [];
-        }
-    }
-    async walkDirectory(dir, files, basePath) {
-        try {
-            const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                const relativePath = path.relative(basePath, fullPath);
-                // Check exclusion patterns
-                if (this.isExcluded(relativePath)) {
-                    continue;
-                }
-                if (entry.isDirectory()) {
-                    await this.walkDirectory(fullPath, files, basePath);
-                }
-                else if (entry.isFile()) {
-                    // Check inclusion patterns
-                    if (this.isIncluded(relativePath)) {
-                        files.push(fullPath);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Skip directories we can't read
-        }
-    }
-    isExcluded(relativePath) {
-        return this.options.excludePatterns.some(pattern => {
-            return this.matchesPattern(relativePath, pattern);
-        });
-    }
-    isIncluded(relativePath) {
-        return this.options.includePatterns.some(pattern => {
-            return this.matchesPattern(relativePath, pattern);
-        });
-    }
-    matchesPattern(filePath, pattern) {
-        // Simple glob pattern matching - in production, use a proper glob library
-        const regexPattern = pattern
-            .replace(/\*\*/g, '.*')
-            .replace(/\*/g, '[^/]*')
-            .replace(/\?/g, '.');
-        const regex = new RegExp(`^${regexPattern}$`);
-        return regex.test(filePath);
-    }
-    async countContextFiles(basePath) {
-        try {
-            const files = await this.findRelevantFiles(basePath);
-            return Math.min(files.length, this.options.maxFiles);
-        }
-        catch (error) {
-            return 0;
-        }
-    }
-    // Public methods to control full context
-    enableFullContext() {
-        this.options.enableFullContext = true;
-    }
-    disableFullContext() {
-        this.options.enableFullContext = false;
-    }
-    isFullContextEnabled() {
-        return this.options.enableFullContext || false;
-    }
-}
-exports.EnvironmentContextModifier = EnvironmentContextModifier;

package/dist/processor-pieces/additionalModifiers/fallbackHandlerModifier.d.ts

@@ -1,38 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface FallbackHandlerOptions {
-    enableFallback?: boolean;
-    maxRetries?: number;
-    fallbackStrategies?: FallbackStrategy[];
-    timeoutMs?: number;
-}
-export declare enum FallbackStrategy {
-    RETRY_WITH_SIMPLIFIED_CONTEXT = "retry_simplified",
-    RETRY_WITHOUT_TOOLS = "retry_no_tools",
-    RETRY_WITH_SHORTER_HISTORY = "retry_short_history",
-    USE_FALLBACK_MODEL = "fallback_model",
-    PROVIDE_ERROR_CONTEXT = "error_context"
-}
-export declare class FallbackHandlerModifier extends BaseMessageModifier {
-    private readonly options;
-    private fallbackContexts;
-    constructor(options?: FallbackHandlerOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private generateMessageId;
-    private shouldApplyFallback;
-    private initializeFallbackContext;
-    private applyFallbackStrategy;
-    private getNextFallbackStrategy;
-    private simplifyContext;
-    private removeTools;
-    private shortenHistory;
-    private setFallbackModel;
-    private addErrorContextMessage;
-    private updateFallbackContext;
-    clearFallbackContext(messageId: string): void;
-    getFallbackStats(): {
-        totalContexts: number;
-        averageAttempts: number;
-    };
-}

package/dist/processor-pieces/additionalModifiers/fallbackHandlerModifier.js

@@ -1,217 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FallbackHandlerModifier = exports.FallbackStrategy = void 0;
-const base_1 = require("../base");
-var FallbackStrategy;
-(function (FallbackStrategy) {
-    FallbackStrategy["RETRY_WITH_SIMPLIFIED_CONTEXT"] = "retry_simplified";
-    FallbackStrategy["RETRY_WITHOUT_TOOLS"] = "retry_no_tools";
-    FallbackStrategy["RETRY_WITH_SHORTER_HISTORY"] = "retry_short_history";
-    FallbackStrategy["USE_FALLBACK_MODEL"] = "fallback_model";
-    FallbackStrategy["PROVIDE_ERROR_CONTEXT"] = "error_context";
-})(FallbackStrategy || (exports.FallbackStrategy = FallbackStrategy = {}));
-class FallbackHandlerModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.fallbackContexts = new Map();
-        this.options = {
-            enableFallback: options.enableFallback !== false,
-            maxRetries: options.maxRetries || 3,
-            fallbackStrategies: options.fallbackStrategies || [
-                FallbackStrategy.RETRY_WITH_SIMPLIFIED_CONTEXT,
-                FallbackStrategy.RETRY_WITHOUT_TOOLS,
-                FallbackStrategy.RETRY_WITH_SHORTER_HISTORY
-            ],
-            timeoutMs: options.timeoutMs || 30000
-        };
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            if (!this.options.enableFallback) {
-                return createdMessage;
-            }
-            // Check if this is a retry attempt
-            const messageId = this.generateMessageId(originalRequest);
-            const fallbackContext = this.fallbackContexts.get(messageId);
-            if (fallbackContext && fallbackContext.attemptCount >= this.options.maxRetries) {
-                // Max retries reached, add error context and return
-                return this.addErrorContextMessage(createdMessage, fallbackContext);
-            }
-            // Check if we need to apply fallback strategies
-            const shouldApplyFallback = this.shouldApplyFallback(createdMessage, fallbackContext);
-            if (!shouldApplyFallback) {
-                return createdMessage;
-            }
-            // Apply the next fallback strategy
-            const modifiedMessage = await this.applyFallbackStrategy(createdMessage, fallbackContext || this.initializeFallbackContext(originalRequest));
-            // Update fallback context
-            this.updateFallbackContext(messageId, modifiedMessage);
-            return modifiedMessage;
-        }
-        catch (error) {
-            console.error('Error in FallbackHandlerModifier:', error);
-            return createdMessage;
-        }
-    }
-    generateMessageId(request) {
-        // Generate a unique ID for this message request
-        const content = request.userMessage || '';
-        return Buffer.from(content).toString('base64').substring(0, 16);
-    }
-    shouldApplyFallback(message, context) {
-        var _a, _b, _c;
-        // Check metadata for error indicators
-        const hasError = !!(((_a = message.metadata) === null || _a === void 0 ? void 0 : _a.hasError) || ((_b = message.metadata) === null || _b === void 0 ? void 0 : _b.lastError));
-        const isRetry = !!((_c = message.metadata) === null || _c === void 0 ? void 0 : _c.isRetry) || ((context === null || context === void 0 ? void 0 : context.attemptCount) || 0) > 0;
-        return hasError || isRetry;
-    }
-    initializeFallbackContext(originalRequest) {
-        const content = originalRequest.userMessage || '';
-        return {
-            attemptCount: 0,
-            originalMessageLength: content.length,
-            fallbacksAttempted: []
-        };
-    }
-    async applyFallbackStrategy(message, context) {
-        const nextStrategy = this.getNextFallbackStrategy(context);
-        if (!nextStrategy) {
-            return message;
-        }
-        context.fallbacksAttempted.push(nextStrategy);
-        switch (nextStrategy) {
-            case FallbackStrategy.RETRY_WITH_SIMPLIFIED_CONTEXT:
-                return this.simplifyContext(message);
-            case FallbackStrategy.RETRY_WITHOUT_TOOLS:
-                return this.removeTools(message);
-            case FallbackStrategy.RETRY_WITH_SHORTER_HISTORY:
-                return this.shortenHistory(message);
-            case FallbackStrategy.USE_FALLBACK_MODEL:
-                return this.setFallbackModel(message);
-            case FallbackStrategy.PROVIDE_ERROR_CONTEXT:
-                return this.addErrorContextMessage(message, context);
-            default:
-                return message;
-        }
-    }
-    getNextFallbackStrategy(context) {
-        const availableStrategies = this.options.fallbackStrategies.filter(strategy => !context.fallbacksAttempted.includes(strategy));
-        return availableStrategies.length > 0 ? availableStrategies[0] : null;
-    }
-    simplifyContext(message) {
-        // Remove or simplify complex context messages
-        const simplifiedMessages = message.message.messages.map(msg => {
-            if (msg.role === 'system' && typeof msg.content === 'string' && msg.content.length > 500) {
-                return {
-                    ...msg,
-                    content: msg.content.substring(0, 500) + '...[context simplified for fallback]'
-                };
-            }
-            return msg;
-        });
-        return {
-            ...message,
-            message: {
-                ...message.message,
-                messages: simplifiedMessages
-            },
-            metadata: {
-                ...message.metadata,
-                fallbackApplied: 'simplified_context',
-                isRetry: true
-            }
-        };
-    }
-    removeTools(message) {
-        return {
-            ...message,
-            metadata: {
-                ...message.metadata,
-                fallbackApplied: 'no_tools',
-                toolsDisabled: true,
-                isRetry: true
-            }
-        };
-    }
-    shortenHistory(message) {
-        // Keep only the last few messages
-        const messages = message.message.messages;
-        const systemMessages = messages.filter(msg => msg.role === 'system');
-        const otherMessages = messages.filter(msg => msg.role !== 'system');
-        const recentMessages = otherMessages.slice(-3); // Keep last 3 non-system messages
-        return {
-            ...message,
-            message: {
-                ...message.message,
-                messages: [...systemMessages, ...recentMessages]
-            },
-            metadata: {
-                ...message.metadata,
-                fallbackApplied: 'shortened_history',
-                originalMessageCount: messages.length,
-                isRetry: true
-            }
-        };
-    }
-    setFallbackModel(message) {
-        return {
-            ...message,
-            metadata: {
-                ...message.metadata,
-                fallbackApplied: 'fallback_model',
-                useFallbackModel: true,
-                isRetry: true
-            }
-        };
-    }
-    addErrorContextMessage(message, context) {
-        const errorMessage = {
-            role: 'system',
-            content: `Note: This request has been attempted ${context.attemptCount} times with fallback strategies: ${context.fallbacksAttempted.join(', ')}. Please provide a simpler response if the request seems too complex.`
-        };
-        return {
-            ...message,
-            message: {
-                ...message.message,
-                messages: [errorMessage, ...message.message.messages]
-            },
-            metadata: {
-                ...message.metadata,
-                fallbackApplied: 'error_context',
-                fallbackExhausted: true,
-                isRetry: true
-            }
-        };
-    }
-    updateFallbackContext(messageId, message) {
-        const existingContext = this.fallbackContexts.get(messageId);
-        if (existingContext) {
-            existingContext.attemptCount++;
-        }
-        else {
-            this.fallbackContexts.set(messageId, {
-                attemptCount: 1,
-                originalMessageLength: JSON.stringify(message.message).length,
-                fallbacksAttempted: []
-            });
-        }
-        // Clean up old contexts (prevent memory leaks)
-        if (this.fallbackContexts.size > 100) {
-            const entries = Array.from(this.fallbackContexts.entries());
-            const oldestKey = entries[0][0];
-            this.fallbackContexts.delete(oldestKey);
-        }
-    }
-    clearFallbackContext(messageId) {
-        this.fallbackContexts.delete(messageId);
-    }
-    getFallbackStats() {
-        const contexts = Array.from(this.fallbackContexts.values());
-        const totalAttempts = contexts.reduce((sum, ctx) => sum + ctx.attemptCount, 0);
-        return {
-            totalContexts: contexts.length,
-            averageAttempts: contexts.length > 0 ? totalAttempts / contexts.length : 0
-        };
-    }
-}
-exports.FallbackHandlerModifier = FallbackHandlerModifier;

package/dist/processor-pieces/additionalModifiers/ideContextModifier.d.ts

@@ -1,34 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface IdeContextOptions {
-    includeOpenFiles?: boolean;
-    includeActiveFile?: boolean;
-    includeCursorPosition?: boolean;
-    includeSelectedText?: boolean;
-    maxOpenFiles?: number;
-}
-export interface FileInfo {
-    path: string;
-    isActive?: boolean;
-    cursor?: {
-        line: number;
-        character: number;
-    };
-    selectedText?: string;
-}
-export interface IdeContext {
-    workspaceState?: {
-        openFiles: FileInfo[];
-    };
-}
-export declare class IdeContextModifier extends BaseMessageModifier {
-    private readonly options;
-    private lastSentIdeContext?;
-    private forceFullContext;
-    constructor(options?: IdeContextOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private getIdeContext;
-    private getIdeContextParts;
-    setForceFullContext(force: boolean): void;
-}