@codebolt/agent 5.0.2 → 5.0.6

package/dist/processor-pieces/messageModifiers/chatHistoryMessageModifier.example.d.ts

@@ -1,20 +0,0 @@
-/**
- * Example usage of ChatHistoryMessageModifier
- *
- * This file demonstrates how to integrate chat history into your agent's message processing pipeline.
- */
-import { InitialPromptGenerator } from '@codebolt/agent/unified';
-import { FlatUserMessage } from '@codebolt/types/sdk';
-export declare function createBasicChatHistoryAgent(): InitialPromptGenerator;
-export declare function createCompactChatHistoryAgent(): InitialPromptGenerator;
-export declare function createThreadAwareChatHistoryAgent(): InitialPromptGenerator;
-export declare function processMessageWithHistory(userMessage: FlatUserMessage): Promise<import("@codebolt/types/agent").ProcessedMessage>;
-export declare const chatHistoryOptions: {
-    enableChatHistory: boolean;
-    maxHistoryMessages: number;
-    includeSystemMessages: boolean;
-    historyContextLabel: string;
-    filterByThreadId: boolean;
-    includeTimestamps: boolean;
-    compactFormat: boolean;
-};

package/dist/processor-pieces/messageModifiers/chatHistoryMessageModifier.example.js

@@ -1,124 +0,0 @@
-"use strict";
-/**
- * Example usage of ChatHistoryMessageModifier
- *
- * This file demonstrates how to integrate chat history into your agent's message processing pipeline.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.chatHistoryOptions = void 0;
-exports.createBasicChatHistoryAgent = createBasicChatHistoryAgent;
-exports.createCompactChatHistoryAgent = createCompactChatHistoryAgent;
-exports.createThreadAwareChatHistoryAgent = createThreadAwareChatHistoryAgent;
-exports.processMessageWithHistory = processMessageWithHistory;
-const chatHistoryMessageModifier_1 = require("./chatHistoryMessageModifier");
-const unified_1 = require("@codebolt/agent/unified");
-// Example 1: Basic chat history integration
-function createBasicChatHistoryAgent() {
-    return new unified_1.InitialPromptGenerator({
-        processors: [
-            // Add chat history before other processors
-            new chatHistoryMessageModifier_1.ChatHistoryMessageModifier({
-                enableChatHistory: true,
-                maxHistoryMessages: 5,
-                includeTimestamps: true,
-                compactFormat: false
-            }),
-            // ... other processors like system prompts, tools, etc.
-        ],
-        baseSystemPrompt: "You are a helpful assistant."
-    });
-}
-// Example 2: Compact chat history for token efficiency
-function createCompactChatHistoryAgent() {
-    return new unified_1.InitialPromptGenerator({
-        processors: [
-            new chatHistoryMessageModifier_1.ChatHistoryMessageModifier({
-                enableChatHistory: true,
-                maxHistoryMessages: 10,
-                includeTimestamps: false,
-                compactFormat: true,
-                includeSystemMessages: false,
-                historyContextLabel: "Previous Conversation"
-            }),
-        ],
-        baseSystemPrompt: "You are a helpful assistant."
-    });
-}
-// Example 3: Thread-specific chat history (when API supports it)
-function createThreadAwareChatHistoryAgent() {
-    return new unified_1.InitialPromptGenerator({
-        processors: [
-            new chatHistoryMessageModifier_1.ChatHistoryMessageModifier({
-                enableChatHistory: true,
-                maxHistoryMessages: 8,
-                filterByThreadId: true, // Filter by thread ID when supported
-                includeTimestamps: true,
-                compactFormat: false,
-                historyContextLabel: "Thread History"
-            }),
-        ],
-        baseSystemPrompt: "You are a helpful assistant."
-    });
-}
-// Example 4: Usage in a real agent scenario
-async function processMessageWithHistory(userMessage) {
-    const promptGenerator = new unified_1.InitialPromptGenerator({
-        processors: [
-            // Chat history comes first to provide context
-            new chatHistoryMessageModifier_1.ChatHistoryMessageModifier({
-                enableChatHistory: true,
-                maxHistoryMessages: 5,
-                includeTimestamps: false,
-                compactFormat: true
-            }),
-            // Add other processors after history
-            // new EnvironmentContextModifier(),
-            // new CoreSystemPromptModifier({ systemPrompt: "..." }),
-            // new ToolInjectionModifier(),
-        ],
-        baseSystemPrompt: "You are a helpful AI assistant."
-    });
-    try {
-        const processedMessage = await promptGenerator.processMessage(userMessage);
-        console.log('Message processed with chat history context');
-        return processedMessage;
-    }
-    catch (error) {
-        console.error('Error processing message with history:', error);
-        throw error;
-    }
-}
-// Example 5: Configuration options explained
-exports.chatHistoryOptions = {
-    // Enable/disable chat history entirely
-    enableChatHistory: true,
-    // Maximum number of previous messages to include
-    maxHistoryMessages: 10,
-    // Include system messages in history
-    includeSystemMessages: false,
-    // Custom label for the history section
-    historyContextLabel: "Previous Conversation",
-    // Filter by thread ID (when API supports it)
-    filterByThreadId: true,
-    // Include timestamps with messages
-    includeTimestamps: true,
-    // Use compact format to save tokens
-    compactFormat: false
-};
-// Example output format:
-/*
-=== Chat History ===
-Thread ID: 6536c82f-c7d1-4dbd-8e68-c90f7ef5ebc3
-Recent 3 messages:
-
-**User (2025-01-15 10:30:15):**
-Can you help me with my React component?
-
-**Assistant (2025-01-15 10:30:45):**
-Of course! I'd be happy to help you with your React component. Could you please share the code or describe what specific issue you're facing?
-
-**User (2025-01-15 10:31:20):**
-I'm having trouble with state management in my component.
-
-=== End Chat History ===
-*/

package/dist/processor-pieces/messageModifiers/environmentContext.d.ts

@@ -1,41 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-export interface Part {
-    text: string;
-}
-export interface EnvironmentContextOptions {
-    workspaceDirectories: string[];
-    includeFullContext?: boolean;
-    maxItems?: number;
-    ignoredFolders?: Set<string>;
-    fileIncludePattern?: RegExp;
-    respectGitIgnore?: boolean;
-    respectGeminiIgnore?: boolean;
-}
-export interface FolderStructureOptions {
-    maxItems?: number;
-    ignoredFolders?: Set<string>;
-    fileIncludePattern?: RegExp;
-    respectGitIgnore?: boolean;
-    respectGeminiIgnore?: boolean;
-}
-/**
- * Standalone version of getFolderStructure
- */
-export declare function getFolderStructure(targetPath: string, options?: FolderStructureOptions): Promise<string>;
-/**
- * Standalone version of getDirectoryContextString
- */
-export declare function getDirectoryContextString(workspaceDirectories: string[], options?: FolderStructureOptions): Promise<string>;
-/**
- * Standalone version of getEnvironmentContext
- */
-export declare function getEnvironmentContext(options: EnvironmentContextOptions): Promise<Part[]>;
-/**
- * Utility function to read multiple files (basic implementation for full context)
- * This is a simplified version - extend as needed for your use case
- */
-export declare function readMultipleFiles(basePath: string, patterns?: string[], options?: FolderStructureOptions): Promise<string>;

package/dist/processor-pieces/messageModifiers/environmentContext.js

@@ -1,355 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-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.getFolderStructure = getFolderStructure;
-exports.getDirectoryContextString = getDirectoryContextString;
-exports.getEnvironmentContext = getEnvironmentContext;
-exports.readMultipleFiles = readMultipleFiles;
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-const MAX_ITEMS = 200;
-const DEFAULT_IGNORED_FOLDERS = new Set(['node_modules', '.git', 'dist']);
-/**
- * Simple gitignore pattern matcher (basic implementation)
- * For production use, consider using a dedicated gitignore library
- */
-function shouldIgnoreFile(filePath, options) {
-    if (!options.respectGitIgnore && !options.respectGeminiIgnore) {
-        return false;
-    }
-    // Basic ignore patterns - in production, you'd want to read actual .gitignore/.geminiignore files
-    const commonIgnorePatterns = [
-        /node_modules/,
-        /\.git/,
-        /dist/,
-        /build/,
-        /\.DS_Store/,
-        /\.env/,
-        /\.log$/,
-        /\.tmp$/,
-        /\.cache/
-    ];
-    return commonIgnorePatterns.some(pattern => pattern.test(filePath));
-}
-/**
- * Reads the full folder structure recursively
- */
-async function readFullStructure(rootPath, options) {
-    const rootName = path.basename(rootPath);
-    const rootNode = {
-        name: rootName,
-        path: rootPath,
-        files: [],
-        subFolders: [],
-        totalChildren: 0,
-        totalFiles: 0,
-    };
-    const queue = [
-        { folderInfo: rootNode, currentPath: rootPath },
-    ];
-    let currentItemCount = 0;
-    const processedPaths = new Set();
-    while (queue.length > 0) {
-        const { folderInfo, currentPath } = queue.shift();
-        if (processedPaths.has(currentPath)) {
-            continue;
-        }
-        processedPaths.add(currentPath);
-        if (currentItemCount >= options.maxItems) {
-            continue;
-        }
-        let entries;
-        try {
-            const rawEntries = await fs.readdir(currentPath, { withFileTypes: true });
-            entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
-        }
-        catch (error) {
-            if (error.code === 'EACCES' || error.code === 'ENOENT') {
-                console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
-                if (currentPath === rootPath && error.code === 'ENOENT') {
-                    return null;
-                }
-                continue;
-            }
-            throw error;
-        }
-        const filesInCurrentDir = [];
-        const subFoldersInCurrentDir = [];
-        // Process files first
-        for (const entry of entries) {
-            if (entry.isFile()) {
-                if (currentItemCount >= options.maxItems) {
-                    folderInfo.hasMoreFiles = true;
-                    break;
-                }
-                const fileName = entry.name;
-                const filePath = path.join(currentPath, fileName);
-                if (shouldIgnoreFile(filePath, options)) {
-                    continue;
-                }
-                if (!options.fileIncludePattern || options.fileIncludePattern.test(fileName)) {
-                    filesInCurrentDir.push(fileName);
-                    currentItemCount++;
-                    folderInfo.totalFiles++;
-                    folderInfo.totalChildren++;
-                }
-            }
-        }
-        folderInfo.files = filesInCurrentDir;
-        // Process directories
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                if (currentItemCount >= options.maxItems) {
-                    folderInfo.hasMoreSubfolders = true;
-                    break;
-                }
-                const subFolderName = entry.name;
-                const subFolderPath = path.join(currentPath, subFolderName);
-                if (options.ignoredFolders.has(subFolderName) || shouldIgnoreFile(subFolderPath, options)) {
-                    const ignoredSubFolder = {
-                        name: subFolderName,
-                        path: subFolderPath,
-                        files: [],
-                        subFolders: [],
-                        totalChildren: 0,
-                        totalFiles: 0,
-                        isIgnored: true,
-                    };
-                    subFoldersInCurrentDir.push(ignoredSubFolder);
-                    currentItemCount++;
-                    folderInfo.totalChildren++;
-                    continue;
-                }
-                const subFolderNode = {
-                    name: subFolderName,
-                    path: subFolderPath,
-                    files: [],
-                    subFolders: [],
-                    totalChildren: 0,
-                    totalFiles: 0,
-                };
-                subFoldersInCurrentDir.push(subFolderNode);
-                currentItemCount++;
-                folderInfo.totalChildren++;
-                queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
-            }
-        }
-        folderInfo.subFolders = subFoldersInCurrentDir;
-    }
-    return rootNode;
-}
-/**
- * Formats a folder structure into a readable string representation
- */
-function formatFolderStructure(folderInfo, prefix = '', isLast = true) {
-    const connector = isLast ? '└── ' : '├── ';
-    const extension = isLast ? '    ' : '│   ';
-    let result = `${prefix}${connector}${folderInfo.name}`;
-    if (folderInfo.isIgnored) {
-        result += ' (ignored)';
-    }
-    result += '\n';
-    // Add files
-    const allFiles = [...folderInfo.files];
-    if (folderInfo.hasMoreFiles) {
-        allFiles.push('...');
-    }
-    allFiles.forEach((file, index) => {
-        const isLastFile = index === allFiles.length - 1 && folderInfo.subFolders.length === 0;
-        const fileConnector = isLastFile ? '└── ' : '├── ';
-        result += `${prefix}${extension}${fileConnector}${file}\n`;
-    });
-    // Add subfolders
-    folderInfo.subFolders.forEach((subFolder, index) => {
-        const isLastSubFolder = index === folderInfo.subFolders.length - 1;
-        result += formatFolderStructure(subFolder, prefix + extension, isLastSubFolder);
-    });
-    if (folderInfo.hasMoreSubfolders) {
-        const moreConnector = '└── ';
-        result += `${prefix}${extension}${moreConnector}...\n`;
-    }
-    return result;
-}
-/**
- * Standalone version of getFolderStructure
- */
-async function getFolderStructure(targetPath, options = {}) {
-    var _a, _b, _c, _d, _e;
-    const mergedOptions = {
-        maxItems: (_a = options.maxItems) !== null && _a !== void 0 ? _a : MAX_ITEMS,
-        ignoredFolders: (_b = options.ignoredFolders) !== null && _b !== void 0 ? _b : DEFAULT_IGNORED_FOLDERS,
-        fileIncludePattern: (_c = options.fileIncludePattern) !== null && _c !== void 0 ? _c : /.*/,
-        respectGitIgnore: (_d = options.respectGitIgnore) !== null && _d !== void 0 ? _d : true,
-        respectGeminiIgnore: (_e = options.respectGeminiIgnore) !== null && _e !== void 0 ? _e : true,
-    };
-    try {
-        const folderInfo = await readFullStructure(targetPath, mergedOptions);
-        if (!folderInfo) {
-            return `Error: Directory not found or inaccessible: ${targetPath}`;
-        }
-        return formatFolderStructure(folderInfo).trim();
-    }
-    catch (error) {
-        return `Error reading folder structure: ${error.message}`;
-    }
-}
-/**
- * Standalone version of getDirectoryContextString
- */
-async function getDirectoryContextString(workspaceDirectories, options = {}) {
-    const folderStructures = await Promise.all(workspaceDirectories.map((dir) => getFolderStructure(dir, options)));
-    const folderStructure = folderStructures.join('\n');
-    let workingDirPreamble;
-    if (workspaceDirectories.length === 1) {
-        workingDirPreamble = `I'm currently working in the directory: ${workspaceDirectories[0]}`;
-    }
-    else {
-        const dirList = workspaceDirectories.map((dir) => `  - ${dir}`).join('\n');
-        workingDirPreamble = `I'm currently working in the following directories:\n${dirList}`;
-    }
-    return `${workingDirPreamble}
-Here is the folder structure of the current working directories:
-
-${folderStructure}`;
-}
-/**
- * Standalone version of getEnvironmentContext
- */
-async function getEnvironmentContext(options) {
-    const today = new Date().toLocaleDateString(undefined, {
-        weekday: 'long',
-        year: 'numeric',
-        month: 'long',
-        day: 'numeric',
-    });
-    const platform = process.platform;
-    const directoryContext = await getDirectoryContextString(options.workspaceDirectories, {
-        maxItems: options.maxItems,
-        ignoredFolders: options.ignoredFolders,
-        fileIncludePattern: options.fileIncludePattern,
-        respectGitIgnore: options.respectGitIgnore,
-        respectGeminiIgnore: options.respectGeminiIgnore,
-    });
-    const context = `
-This is the Gemini CLI. We are setting up the context for our chat.
-Today's date is ${today}.
-My operating system is: ${platform}
-${directoryContext}
-        `.trim();
-    const initialParts = [{ text: context }];
-    // Add full file context if requested
-    if (options.includeFullContext) {
-        try {
-            // This is a simplified version - in the original, this would use read_many_files tool
-            // For standalone use, you might want to implement your own file reading logic
-            const fullContextNote = `
---- Full File Context (Standalone Version) ---
-Note: Full file context reading would require implementing file reading logic
-based on your specific needs. The original implementation uses the read_many_files tool
-from the Gemini CLI tool registry.
-`;
-            initialParts.push({ text: fullContextNote });
-        }
-        catch (error) {
-            console.error('Error reading full file context:', error);
-            initialParts.push({
-                text: '\n--- Error reading full file context ---',
-            });
-        }
-    }
-    return initialParts;
-}
-/**
- * Utility function to read multiple files (basic implementation for full context)
- * This is a simplified version - extend as needed for your use case
- */
-async function readMultipleFiles(basePath, patterns = ['**/*'], options = {}) {
-    // This is a basic implementation - for production use, consider using a glob library
-    // like 'glob' or 'fast-glob' for pattern matching
-    try {
-        const files = [];
-        async function collectFiles(dirPath, currentDepth = 0) {
-            var _a;
-            if (currentDepth > 10)
-                return; // Prevent infinite recursion
-            try {
-                const entries = await fs.readdir(dirPath, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(dirPath, entry.name);
-                    if (shouldIgnoreFile(fullPath, options)) {
-                        continue;
-                    }
-                    if (entry.isFile()) {
-                        files.push(fullPath);
-                    }
-                    else if (entry.isDirectory() && !((_a = options.ignoredFolders) === null || _a === void 0 ? void 0 : _a.has(entry.name))) {
-                        await collectFiles(fullPath, currentDepth + 1);
-                    }
-                }
-            }
-            catch (error) {
-                // Skip directories we can't read
-                console.warn(`Warning: Could not read directory ${dirPath}: ${error.message}`);
-            }
-        }
-        await collectFiles(basePath);
-        // Read file contents (limit to reasonable size)
-        const fileContents = [];
-        for (const filePath of files.slice(0, 100)) { // Limit to first 100 files
-            try {
-                const stats = await fs.stat(filePath);
-                if (stats.size > 100 * 1024) { // Skip files larger than 100KB
-                    fileContents.push(`${filePath}: [File too large, skipped]`);
-                    continue;
-                }
-                const content = await fs.readFile(filePath, 'utf-8');
-                const relativePath = path.relative(basePath, filePath);
-                fileContents.push(`--- ${relativePath} ---\n${content}\n`);
-            }
-            catch (error) {
-                fileContents.push(`${filePath}: [Error reading file: ${error.message}]`);
-            }
-        }
-        return fileContents.join('\n');
-    }
-    catch (error) {
-        return `Error reading multiple files: ${error.message}`;
-    }
-}

package/dist/processor-pieces/messageModifiers/mentionedFilesModifier.d.ts

@@ -1,23 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-/**
- * Message modifier that reads files and folders mentioned in the user message
- * Uses mentionedFiles and mentionedFolders from FlatUserMessage
- */
-export declare class MentionedFilesModifier extends BaseMessageModifier {
-    constructor();
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    /**
-     * Resolves and reads a file, handling both files and directories
-     */
-    private resolveAndReadFile;
-    /**
-     * Formats file content for inclusion in the message
-     */
-    private formatFileContent;
-    /**
-     * Updates the user message with file content
-     */
-    private updateUserMessage;
-}