@codebolt/agent 1.2.1 → 2.2.3

package/dist/processor/messageModifiers/baseMessageModifier.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestMessage = exports.BaseMessageModifier = void 0;
+class BaseMessageModifier {
+    constructor(options = {}) {
+        this.context = {};
+        this.context = options.context || {};
+    }
+    setContext(key, value) {
+        this.context[key] = value;
+    }
+    getContext(key) {
+        return this.context[key];
+    }
+    clearContext() {
+        this.context = {};
+    }
+}
+exports.BaseMessageModifier = BaseMessageModifier;
+// New RequestMessage class that can chain multiple modifiers
+class RequestMessage {
+    constructor(options = {}) {
+        this.messageModifiers = [];
+        this.messageModifiers = options.messageModifiers || [];
+    }
+    addModifier(modifier) {
+        this.messageModifiers.push(modifier);
+    }
+    async modify(message) {
+        let currentMessage = {
+            messages: [
+                {
+                    role: 'user',
+                    content: typeof message === 'string' ? message : JSON.stringify(message)
+                }
+            ]
+        };
+        // Apply each modifier in sequence
+        for (const modifier of this.messageModifiers) {
+            try {
+                currentMessage = await modifier.modify({
+                    originalRequest: message,
+                    createdMessage: currentMessage,
+                    context: {}
+                });
+            }
+            catch (error) {
+                console.error('Error applying message modifier:', error);
+                // Continue with other modifiers
+            }
+        }
+        return currentMessage;
+    }
+}
+exports.RequestMessage = RequestMessage;

package/dist/processor/processors/baseProcessor.d.ts

@@ -0,0 +1,14 @@
+import { Processor, ProcessorInput, ProcessorOutput } from '../types/interfaces';
+export declare abstract class BaseProcessor implements Processor {
+    protected context: Record<string, any>;
+    constructor(options?: Record<string, any>);
+    abstract processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    setContext(key: string, value: any): void;
+    getContext(key: string): any;
+    clearContext(): void;
+    protected createEvent(type: string, value?: any): ProcessorOutput;
+    protected createEvents(...events: Array<{
+        type: string;
+        value?: any;
+    }>): ProcessorOutput[];
+}

package/dist/processor/processors/baseProcessor.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProcessor = void 0;
+class BaseProcessor {
+    constructor(options) {
+        this.context = {};
+        if (options) {
+            this.context = { ...options };
+        }
+    }
+    setContext(key, value) {
+        this.context[key] = value;
+    }
+    getContext(key) {
+        return this.context[key];
+    }
+    clearContext() {
+        this.context = {};
+    }
+    // Helper method to create events
+    createEvent(type, value) {
+        return { type, value };
+    }
+    // Helper method to create multiple events
+    createEvents(...events) {
+        return events.map(event => this.createEvent(event.type, event.value));
+    }
+}
+exports.BaseProcessor = BaseProcessor;

package/dist/processor/tools/baseTool.d.ts

@@ -0,0 +1,10 @@
+import { Tool } from '../types/interfaces';
+export declare abstract class BaseTool implements Tool {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, any>;
+    constructor(name: string, description: string, parameters: Record<string, any>);
+    abstract execute(params: any, abortSignal?: AbortSignal): Promise<any>;
+    protected checkAbortSignal(abortSignal?: AbortSignal): void;
+    protected validateParameters(params: any): boolean;
+}

package/dist/processor/tools/baseTool.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTool = void 0;
+class BaseTool {
+    constructor(name, description, parameters) {
+        this.name = name;
+        this.description = description;
+        this.parameters = parameters;
+    }
+    checkAbortSignal(abortSignal) {
+        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+            throw new Error('Operation was aborted');
+        }
+    }
+    validateParameters(params) {
+        // Basic validation - can be overridden by subclasses
+        return params && typeof params === 'object';
+    }
+}
+exports.BaseTool = BaseTool;

package/dist/processor/tools/toolList.d.ts

@@ -0,0 +1,9 @@
+import { ToolList as IToolList, Tool } from '../types/interfaces';
+export declare class ToolList implements IToolList {
+    private tools;
+    constructor(tools?: Tool[]);
+    getTool(name: string): Tool | undefined;
+    getAllTools(): Tool[];
+    addTool(tool: Tool): void;
+    removeTool(name: string): void;
+}

package/dist/processor/tools/toolList.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolList = void 0;
+class ToolList {
+    constructor(tools = []) {
+        this.tools = new Map();
+        tools.forEach(tool => this.addTool(tool));
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    getAllTools() {
+        return Array.from(this.tools.values());
+    }
+    addTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    removeTool(name) {
+        this.tools.delete(name);
+    }
+}
+exports.ToolList = ToolList;

package/dist/processor/types/interfaces.d.ts

@@ -0,0 +1,117 @@
+import type { FlatUserMessage } from '@codebolt/types';
+export interface ToolCall {
+    /** Unique identifier for this tool call */
+    id: string;
+    /** The type of tool call */
+    type: 'function';
+    /** Function call details */
+    function: {
+        /** Name of the function to call */
+        name: string;
+        /** Arguments for the function call as JSON string */
+        arguments: string;
+    };
+}
+export interface Message {
+    /** Role of the message sender */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /** Content of the message */
+    content: string | Array<{
+        type: string;
+        text: string;
+    }>;
+    /** Optional name for the message sender */
+    name?: string;
+    /** Tool call ID for tool messages */
+    tool_call_id?: string;
+    /** Tool calls for assistant messages */
+    tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}
+export interface ProcessedMessage {
+    /** Array of messages in OpenAI format */
+    messages: Message[];
+    /** Optional metadata about the processing */
+    metadata?: Record<string, unknown>;
+}
+export interface ProcessorInput {
+    message: ProcessedMessage;
+    context?: Record<string, unknown>;
+}
+export interface ProcessorOutput {
+    type: string;
+    value?: unknown;
+}
+export interface Processor {
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    clearContext(): void;
+}
+export interface MessageModifierInput {
+    originalRequest: FlatUserMessage;
+    createdMessage: ProcessedMessage;
+    context?: Record<string, unknown>;
+}
+export interface MessageModifier {
+    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    clearContext(): void;
+}
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute(params: unknown, abortSignal?: AbortSignal): Promise<unknown>;
+}
+export interface ToolList {
+    getTool(name: string): Tool | undefined;
+    getAllTools(): Tool[];
+    addTool(tool: Tool): void;
+    removeTool(name: string): void;
+}
+export interface AgentStepInput {
+    message: ProcessedMessage;
+    tools: Tool[];
+    context?: Record<string, unknown>;
+}
+export interface AgentStepOutput {
+    response: ProcessedMessage;
+    toolCalls?: Array<{
+        tool: string;
+        parameters: unknown;
+    }>;
+    finished: boolean;
+}
+export interface IAgentStep {
+    generateOneStep(input: AgentStepInput): Promise<AgentStepOutput>;
+    generateWithToolExecution(input: AgentStepInput): Promise<AgentStepOutput>;
+    loop(input: AgentStepInput, maxIterations?: number): Promise<AgentStepOutput>;
+}
+export interface ToolExecutionInput {
+    toolCalls: Array<{
+        tool: string;
+        parameters: unknown;
+    }>;
+    tools: ToolList;
+    context?: Record<string, unknown>;
+}
+export interface ToolExecutionOutput {
+    results: Array<{
+        tool: string;
+        result: unknown;
+        error?: string;
+    }>;
+    success: boolean;
+}
+export interface ToolExecutor {
+    executeTools(input: ToolExecutionInput): Promise<ToolExecutionOutput>;
+}
+export type AgentEventType = 'content' | 'tool_call_request' | 'tool_call_response' | 'tool_call_confirmation' | 'user_cancelled' | 'error' | 'chat_compressed' | 'thought' | 'max_session_turns' | 'finished' | 'loop_detected';

package/dist/processor/types/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,13 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ArgumentProcessorOptions {
+    appendRawInvocation?: boolean;
+    argumentSeparator?: string;
+    includeCommandName?: boolean;
+}
+export declare class ArgumentProcessorModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: ArgumentProcessorOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentProcessorModifier = void 0;
+const base_1 = require("../base");
+class ArgumentProcessorModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            appendRawInvocation: options.appendRawInvocation !== false,
+            argumentSeparator: options.argumentSeparator || ' ',
+            includeCommandName: options.includeCommandName || false
+        };
+    }
+    modify(originalRequest, createdMessage) {
+        var _a;
+        try {
+            // Get arguments from metadata
+            const invocation = (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.invocation;
+            if (!(invocation === null || invocation === void 0 ? void 0 : invocation.args)) {
+                return Promise.resolve(createdMessage);
+            }
+            // Find the user message to append arguments to
+            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            if (!userMessage || typeof userMessage.content !== 'string') {
+                return Promise.resolve(createdMessage);
+            }
+            let appendContent = '';
+            if (this.options.appendRawInvocation && invocation.raw) {
+                // Append the full raw command invocation
+                appendContent = `\n\nFull command: ${invocation.raw}`;
+            }
+            else {
+                // Append just the arguments
+                let argsToAppend = invocation.args;
+                if (this.options.includeCommandName && invocation.name) {
+                    argsToAppend = `${invocation.name}${this.options.argumentSeparator}${argsToAppend}`;
+                }
+                appendContent = `\n\nArguments: ${argsToAppend}`;
+            }
+            // Update the user message with appended arguments
+            const updatedMessages = createdMessage.message.messages.map(msg => {
+                if (msg.role === 'user' && typeof msg.content === 'string' && msg === userMessage) {
+                    return {
+                        ...msg,
+                        content: msg.content + appendContent
+                    };
+                }
+                return msg;
+            });
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages: updatedMessages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    argumentsProcessed: true,
+                    argumentsAppended: appendContent.trim()
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in ArgumentProcessorModifier:', error);
+            return Promise.resolve(createdMessage);
+        }
+    }
+}
+exports.ArgumentProcessorModifier = ArgumentProcessorModifier;

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

@@ -0,0 +1,15 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface AtFileProcessorOptions {
+    maxFileSize?: number;
+    allowedExtensions?: string[];
+    basePath?: string;
+}
+export declare class AtFileProcessorModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: AtFileProcessorOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private readFileContent;
+    private getFolderStructure;
+}

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

@@ -0,0 +1,212 @@
+"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.AtFileProcessorModifier = void 0;
+const base_1 = require("../base");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class AtFileProcessorModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            maxFileSize: options.maxFileSize || 1024 * 1024, // 1MB default
+            allowedExtensions: options.allowedExtensions || ['.ts', '.js', '.json', '.md', '.txt', '.yml', '.yaml', '.xml', '.html', '.css', '.py', '.java', '.cpp', '.c', '.h'],
+            basePath: options.basePath || process.cwd()
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const mentionedFiles = originalRequest.mentionedFiles || [];
+            const mentionedFolders = originalRequest.mentionedFolders || [];
+            if (mentionedFiles.length === 0 && mentionedFolders.length === 0) {
+                return createdMessage;
+            }
+            const contextParts = [];
+            // Process mentioned files
+            if (mentionedFiles.length > 0) {
+                const fileContents = await Promise.all(mentionedFiles.map(async (filePath) => {
+                    try {
+                        const content = await this.readFileContent(filePath);
+                        return `--- Content from ${filePath} ---\n${content}\n--- End of ${filePath} ---`;
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        return `[Error loading ${filePath}: ${errorMessage}]`;
+                    }
+                }));
+                contextParts.push(`File Contents:\n${fileContents.join('\n\n')}`);
+            }
+            // Process mentioned folders
+            if (mentionedFolders.length > 0) {
+                const folderContents = await Promise.all(mentionedFolders.map(async (folderPath) => {
+                    try {
+                        const structure = await this.getFolderStructure(folderPath);
+                        return `--- Structure of ${folderPath} ---\n${structure}\n--- End of ${folderPath} ---`;
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        return `[Error reading folder ${folderPath}: ${errorMessage}]`;
+                    }
+                }));
+                contextParts.push(`Folder Structures:\n${folderContents.join('\n\n')}`);
+            }
+            // Find the last user message and append context to it
+            const messages = [...createdMessage.message.messages];
+            let lastUserMessageIndex = -1;
+            for (let i = messages.length - 1; i >= 0; i--) {
+                if (messages[i].role === 'user') {
+                    lastUserMessageIndex = i;
+                    break;
+                }
+            }
+            if (lastUserMessageIndex !== -1) {
+                const lastUserMessage = messages[lastUserMessageIndex];
+                const currentContent = Array.isArray(lastUserMessage.content)
+                    ? lastUserMessage.content
+                    : [{ type: 'text', text: lastUserMessage.content }];
+                // Add context as additional content parts
+                const contextContent = {
+                    type: 'text',
+                    text: contextParts.join('\n\n')
+                };
+                messages[lastUserMessageIndex] = {
+                    ...lastUserMessage,
+                    content: [...currentContent, contextContent]
+                };
+            }
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    atFileProcessed: true,
+                    processedFiles: mentionedFiles,
+                    processedFolders: mentionedFolders
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in AtFileProcessorModifier:', error);
+            return createdMessage;
+        }
+    }
+    async readFileContent(filePath) {
+        // Resolve path relative to base path
+        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(this.options.basePath, filePath);
+        // Security check: ensure the file is within allowed directory
+        const relativePath = path.relative(this.options.basePath, resolvedPath);
+        if (relativePath.startsWith('..')) {
+            throw new Error(`Access denied: ${filePath} is outside the allowed directory`);
+        }
+        // Check if file exists
+        try {
+            await fs.promises.access(resolvedPath, fs.constants.R_OK);
+        }
+        catch (error) {
+            throw new Error(`File not found or not readable: ${filePath}`);
+        }
+        // Check file size
+        const stats = await fs.promises.stat(resolvedPath);
+        if (stats.size > this.options.maxFileSize) {
+            throw new Error(`File too large: ${filePath} (${stats.size} bytes, max ${this.options.maxFileSize} bytes)`);
+        }
+        // Check file extension if allowedExtensions is specified
+        if (this.options.allowedExtensions.length > 0) {
+            const ext = path.extname(resolvedPath).toLowerCase();
+            if (!this.options.allowedExtensions.includes(ext)) {
+                throw new Error(`File type not allowed: ${ext}`);
+            }
+        }
+        // Read and return file content
+        const content = await fs.promises.readFile(resolvedPath, 'utf-8');
+        return content;
+    }
+    async getFolderStructure(folderPath) {
+        // Resolve path relative to base path
+        const resolvedPath = path.isAbsolute(folderPath) ? folderPath : path.resolve(this.options.basePath, folderPath);
+        // Security check: ensure the folder is within allowed directory
+        const relativePath = path.relative(this.options.basePath, resolvedPath);
+        if (relativePath.startsWith('..')) {
+            throw new Error(`Access denied: ${folderPath} is outside the allowed directory`);
+        }
+        // Check if folder exists and is readable
+        try {
+            await fs.promises.access(resolvedPath, fs.constants.R_OK);
+            const stats = await fs.promises.stat(resolvedPath);
+            if (!stats.isDirectory()) {
+                throw new Error(`${folderPath} is not a directory`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Folder not found or not readable: ${folderPath}`);
+        }
+        // Read directory structure
+        try {
+            const entries = await fs.promises.readdir(resolvedPath, { withFileTypes: true });
+            const lines = [];
+            // Sort entries: directories first, then files
+            const sortedEntries = entries.sort((a, b) => {
+                if (a.isDirectory() && !b.isDirectory())
+                    return -1;
+                if (!a.isDirectory() && b.isDirectory())
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+            for (const entry of sortedEntries.slice(0, 50)) { // Limit to 50 entries
+                if (entry.name.startsWith('.'))
+                    continue; // Skip hidden files
+                if (entry.isDirectory()) {
+                    lines.push(`${folderPath}/${entry.name}/`);
+                }
+                else {
+                    const filePath = path.join(resolvedPath, entry.name);
+                    const stats = await fs.promises.stat(filePath);
+                    const size = stats.size < 1024 ? `${stats.size}B` : `${Math.round(stats.size / 1024)}KB`;
+                    lines.push(`${folderPath}/${entry.name} (${size})`);
+                }
+            }
+            if (entries.length > 50) {
+                lines.push(`... and ${entries.length - 50} more items`);
+            }
+            return lines.join('\n');
+        }
+        catch (error) {
+            throw new Error(`Error reading folder structure: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+}
+exports.AtFileProcessorModifier = AtFileProcessorModifier;

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

@@ -0,0 +1,19 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ChatCompressionOptions {
+    tokenThreshold?: number;
+    compressionRatio?: number;
+    preserveRecentMessages?: number;
+    enableCompression?: boolean;
+}
+export declare class ChatCompressionModifier extends BaseMessageModifier {
+    private readonly options;
+    private hasFailedCompressionAttempt;
+    constructor(options?: ChatCompressionOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private shouldCompressChat;
+    private compressMessages;
+    private createConversationSummary;
+    resetCompressionState(): void;
+}