@codebolt/agent 5.0.6 → 5.0.8

package/dist/processor-pieces/base/basePreToolCallProcessor.js

@@ -27,13 +27,16 @@ class BasePreToolCallProcessor {
     }
     // Helper method to create intercepted tool result
     createInterceptedTool(toolName, originalInput, result, reason) {
-        return {
+        const interceptedTool = {
             toolName,
             originalInput,
             result,
             intercepted: true,
-            reason,
         };
+        if (reason !== undefined) {
+            interceptedTool.reason = reason;
+        }
+        return interceptedTool;
     }
     // Helper method to validate tool call
     validateToolCall(toolCall, validationRules) {

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

@@ -9,5 +9,5 @@ export interface ArgumentProcessorOptions {
 export declare class ArgumentProcessorModifier extends BaseMessageModifier {
     private readonly options;
     constructor(options?: ArgumentProcessorOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
 }

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

@@ -11,11 +11,11 @@ class ArgumentProcessorModifier extends base_1.BaseMessageModifier {
             includeCommandName: options.includeCommandName || false
         };
     }
-    modify(originalRequest, createdMessage) {
+    modify(_originalRequest, createdMessage) {
         var _a;
         try {
             // Get arguments from metadata
-            const invocation = (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.invocation;
+            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);
             }

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

@@ -41,10 +41,6 @@ const base_1 = require("../base");
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-const DEFAULT_FILE_FILTERING_OPTIONS = {
-    respectGitIgnore: true,
-    respectGeminiIgnore: true,
-};
 class AtFileProcessorModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -71,24 +67,26 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
             const lastUserMessageIndex = this.findLastUserMessage(messages);
             if (lastUserMessageIndex !== -1 && result.processedContent) {
                 const lastUserMessage = messages[lastUserMessageIndex];
-                // Convert string content to array format if needed
-                let currentContent;
-                if (Array.isArray(lastUserMessage.content)) {
-                    currentContent = lastUserMessage.content;
-                }
-                else {
-                    // Convert string content to array format
-                    currentContent = [{ type: 'text', text: lastUserMessage.content }];
+                if (lastUserMessage) {
+                    // Convert string content to array format if needed
+                    let currentContent;
+                    if (Array.isArray(lastUserMessage.content)) {
+                        currentContent = lastUserMessage.content;
+                    }
+                    else {
+                        // Convert string content to array format
+                        currentContent = [{ type: 'text', text: lastUserMessage.content }];
+                    }
+                    // Ensure processedContent is in array format
+                    const newContent = Array.isArray(result.processedContent)
+                        ? result.processedContent
+                        : [{ type: 'text', text: result.processedContent }];
+                    // Merge existing content with processed content
+                    messages[lastUserMessageIndex] = {
+                        role: lastUserMessage.role,
+                        content: [...currentContent, ...newContent]
+                    };
                 }
-                // Ensure processedContent is in array format
-                const newContent = Array.isArray(result.processedContent)
-                    ? result.processedContent
-                    : [{ type: 'text', text: result.processedContent }];
-                // Merge existing content with processed content
-                messages[lastUserMessageIndex] = {
-                    ...lastUserMessage,
-                    content: [...currentContent, ...newContent]
-                };
             }
             return {
                 message: {
@@ -255,8 +253,9 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
         try {
             const pattern = `**/*${pathName}*`;
             const matches = await this.findFiles(dir, pattern);
-            if (matches.length > 0) {
-                return path.relative(dir, matches[0]);
+            const firstMatch = matches[0];
+            if (firstMatch !== undefined) {
+                return path.relative(dir, firstMatch);
             }
         }
         catch (error) {
@@ -289,16 +288,6 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
         const results = [];
         // Try to use read_many_files tool if available (like gemini-cli)
         try {
-            // In a real implementation, this would use the actual tool registry
-            // For now, we'll simulate the tool behavior
-            const toolArgs = {
-                paths: pathSpecs,
-                useDefaultExcludes: true,
-                file_filtering_options: {
-                    respect_git_ignore: DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore,
-                    respect_gemini_ignore: DEFAULT_FILE_FILTERING_OPTIONS.respectGeminiIgnore,
-                }
-            };
             // Simulate read_many_files tool execution
             for (const pathSpec of pathSpecs) {
                 try {
@@ -430,7 +419,8 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
     }
     findLastUserMessage(messages) {
         for (let i = messages.length - 1; i >= 0; i--) {
-            if (messages[i].role === 'user') {
+            const message = messages[i];
+            if (message && message.role === 'user') {
                 return i;
             }
         }

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

@@ -10,7 +10,7 @@ export interface ChatRecordingOptions {
 }
 export declare class ChatRecordingModifier extends BaseMessageModifier {
     private readonly options;
-    private recordingFile?;
+    private recordingFile;
     constructor(options?: ChatRecordingOptions);
     modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     private initializeRecording;

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

@@ -110,8 +110,8 @@ class ChatRecordingModifier extends base_1.BaseMessageModifier {
             for (const message of createdMessage.message.messages) {
                 const record = {
                     timestamp,
-                    messageId: (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.messageId,
-                    threadId: (_b = createdMessage.metadata) === null || _b === void 0 ? void 0 : _b.threadId,
+                    messageId: (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a['messageId'],
+                    threadId: (_b = createdMessage.metadata) === null || _b === void 0 ? void 0 : _b['threadId'],
                     role: message.role,
                     content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content)
                 };

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

@@ -8,7 +8,7 @@ export interface CoreSystemPromptOptions {
 export declare class CoreSystemPromptModifier extends BaseMessageModifier {
     private readonly options;
     constructor(options?: CoreSystemPromptOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     private getCoreSystemPrompt;
     private getDefaultSystemPrompt;
 }

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

@@ -7,10 +7,10 @@ class CoreSystemPromptModifier extends base_1.BaseMessageModifier {
         super();
         this.options = options;
     }
-    modify(originalRequest, createdMessage) {
+    modify(_originalRequest, createdMessage) {
         var _a;
         // Get user memory from metadata or options
-        const userMemory = ((_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.userMemory) || this.options.userMemory;
+        const userMemory = ((_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a['userMemory']) || this.options.userMemory;
         const systemPrompt = this.options.customSystemPrompt || this.getCoreSystemPrompt(userMemory);
         const systemMessage = {
             role: 'system',

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

@@ -9,7 +9,7 @@ export declare class DirectoryContextModifier extends BaseMessageModifier {
     private gitignorePatterns;
     private gitignoreRegexes;
     constructor(options?: DirectoryContextOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     private loadGitignorePatterns;
     private parseGitignoreContent;
     private isGitIgnored;

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

@@ -69,7 +69,7 @@ class DirectoryContextModifier extends base_1.BaseMessageModifier {
             workspaceDirectories: options.workspaceDirectories || []
         };
     }
-    async modify(originalRequest, createdMessage) {
+    async modify(_originalRequest, createdMessage) {
         try {
             // Get workspace directories from codebolt or use provided options
             let workspaceDirectories = this.options.workspaceDirectories;
@@ -211,8 +211,10 @@ ${folderStructure}`;
         const mergedOptions = {
             maxItems: (_a = options === null || options === void 0 ? void 0 : options.maxItems) !== null && _a !== void 0 ? _a : MAX_ITEMS,
             ignoredFolders: (_b = options === null || options === void 0 ? void 0 : options.ignoredFolders) !== null && _b !== void 0 ? _b : DEFAULT_IGNORED_FOLDERS,
-            fileIncludePattern: options === null || options === void 0 ? void 0 : options.fileIncludePattern,
         };
+        if (options === null || options === void 0 ? void 0 : options.fileIncludePattern) {
+            mergedOptions.fileIncludePattern = options.fileIncludePattern;
+        }
         try {
             // 1. Read the structure using BFS, respecting maxItems
             const structureRoot = await this.readFullStructure(resolvedPath, mergedOptions);
@@ -408,7 +410,10 @@ ${folderStructure}`;
         for (let i = 0; i < subFolderCount; i++) {
             const isLastSubfolderAmongSiblings = i === subFolderCount - 1 && !node.hasMoreSubfolders;
             // Children are never the root node being processed initially.
-            this.formatStructure(node.subFolders[i], indentForChildren, isLastSubfolderAmongSiblings, false, builder);
+            const subFolder = node.subFolders[i];
+            if (subFolder) {
+                this.formatStructure(subFolder, indentForChildren, isLastSubfolderAmongSiblings, false, builder);
+            }
         }
         if (node.hasMoreSubfolders) {
             builder.push(`${indentForChildren}└───${TRUNCATION_INDICATOR}`);

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

@@ -12,7 +12,7 @@ export declare class EnvironmentContextModifier extends BaseMessageModifier {
     private readonly options;
     private readonly defaultExcludePatterns;
     constructor(options?: EnvironmentContextOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     private generateFullContext;
     private findRelevantFiles;
     private walkDirectory;

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

@@ -66,7 +66,7 @@ class EnvironmentContextModifier extends base_1.BaseMessageModifier {
             excludePatterns: [...this.defaultExcludePatterns, ...(options.excludePatterns || [])]
         };
     }
-    async modify(originalRequest, createdMessage) {
+    async modify(_originalRequest, createdMessage) {
         try {
             // Get current date formatted to user's locale
             const today = new Date().toLocaleDateString(undefined, {

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

@@ -34,16 +34,21 @@ class IdeContextModifier extends base_1.BaseMessageModifier {
             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${ideContextMessage.content}`
-                };
+                const existingMessage = messages[systemMessageIndex];
+                if (existingMessage) {
+                    messages[systemMessageIndex] = {
+                        role: existingMessage.role,
+                        content: `${existingMessage.content}\n\n${ideContextMessage.content}`
+                    };
+                }
             }
             else {
                 // Add new system message
                 messages.unshift(ideContextMessage);
             }
-            this.lastSentIdeContext = newIdeContext;
+            if (newIdeContext) {
+                this.lastSentIdeContext = newIdeContext;
+            }
             this.forceFullContext = false;
             return Promise.resolve({
                 message: {
@@ -64,8 +69,8 @@ class IdeContextModifier extends base_1.BaseMessageModifier {
     }
     getIdeContext(originalRequest, metadata) {
         // Try to get IDE context from the metadata parameter first
-        if (metadata === null || metadata === void 0 ? void 0 : metadata.ideContext) {
-            return metadata.ideContext;
+        if (metadata === null || metadata === void 0 ? void 0 : metadata['ideContext']) {
+            return metadata['ideContext'];
         }
         // Extract IDE context from the original message
         const activeFile = originalRequest.activeFile;
@@ -102,7 +107,7 @@ class IdeContextModifier extends base_1.BaseMessageModifier {
         };
     }
     getIdeContextParts(forceFullContext, currentIdeContext) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         if (!((_a = currentIdeContext === null || currentIdeContext === void 0 ? void 0 : currentIdeContext.workspaceState) === null || _a === void 0 ? void 0 : _a.openFiles)) {
             return { contextParts: [], newIdeContext: undefined };
         }
@@ -119,14 +124,16 @@ class IdeContextModifier extends base_1.BaseMessageModifier {
                 const activeFileData = {
                     path: activeFile.path
                 };
-                if (this.options.includeCursorPosition && activeFile.cursor) {
-                    activeFileData.cursor = {
-                        line: activeFile.cursor.line,
-                        character: activeFile.cursor.character,
+                const cursor = activeFile['cursor'];
+                if (this.options.includeCursorPosition && cursor) {
+                    activeFileData['cursor'] = {
+                        line: cursor.line,
+                        character: cursor.character,
                     };
                 }
-                if (this.options.includeSelectedText && activeFile.selectedText) {
-                    activeFileData.selectedText = activeFile.selectedText;
+                const selectedText = activeFile['selectedText'];
+                if (this.options.includeSelectedText && selectedText) {
+                    activeFileData['selectedText'] = selectedText;
                 }
                 contextData['activeFile'] = activeFileData;
             }
@@ -146,9 +153,99 @@ class IdeContextModifier extends base_1.BaseMessageModifier {
             ];
             return { contextParts, newIdeContext: currentIdeContext };
         }
-        // For incremental updates, we would compare with lastSentIdeContext
-        // and only send changes. For now, we'll skip incremental updates.
-        return { contextParts: [], newIdeContext: currentIdeContext };
+        // Calculate and send delta as JSON
+        const delta = {};
+        const changes = {};
+        const lastFiles = new Map((((_b = this.lastSentIdeContext.workspaceState) === null || _b === void 0 ? void 0 : _b.openFiles) || []).map((f) => [f.path, f]));
+        const currentFiles = new Map((((_c = currentIdeContext.workspaceState) === null || _c === void 0 ? void 0 : _c.openFiles) || []).map((f) => [
+            f.path,
+            f,
+        ]));
+        const openedFiles = [];
+        for (const [path] of currentFiles.entries()) {
+            if (!lastFiles.has(path)) {
+                openedFiles.push(path);
+            }
+        }
+        if (openedFiles.length > 0) {
+            changes['filesOpened'] = openedFiles;
+        }
+        const closedFiles = [];
+        for (const [path] of lastFiles.entries()) {
+            if (!currentFiles.has(path)) {
+                closedFiles.push(path);
+            }
+        }
+        if (closedFiles.length > 0) {
+            changes['filesClosed'] = closedFiles;
+        }
+        const lastActiveFile = (((_d = this.lastSentIdeContext.workspaceState) === null || _d === void 0 ? void 0 : _d.openFiles) || []).find((f) => f.isActive);
+        const currentActiveFile = (((_e = currentIdeContext.workspaceState) === null || _e === void 0 ? void 0 : _e.openFiles) || []).find((f) => f.isActive);
+        if (currentActiveFile) {
+            if (!lastActiveFile || lastActiveFile.path !== currentActiveFile.path) {
+                const activeFileChange = {
+                    path: currentActiveFile.path
+                };
+                if (this.options.includeCursorPosition && currentActiveFile.cursor) {
+                    activeFileChange['cursor'] = {
+                        line: currentActiveFile.cursor.line,
+                        character: currentActiveFile.cursor.character,
+                    };
+                }
+                if (this.options.includeSelectedText && currentActiveFile.selectedText) {
+                    activeFileChange['selectedText'] = currentActiveFile.selectedText;
+                }
+                changes['activeFileChanged'] = activeFileChange;
+            }
+            else {
+                const lastCursor = lastActiveFile.cursor;
+                const currentCursor = currentActiveFile.cursor;
+                if (this.options.includeCursorPosition &&
+                    currentCursor &&
+                    (!lastCursor ||
+                        lastCursor.line !== currentCursor.line ||
+                        lastCursor.character !== currentCursor.character)) {
+                    changes['cursorMoved'] = {
+                        path: currentActiveFile.path,
+                        cursor: {
+                            line: currentCursor.line,
+                            character: currentCursor.character,
+                        },
+                    };
+                }
+                const lastSelectedText = lastActiveFile.selectedText || '';
+                const currentSelectedText = currentActiveFile.selectedText || '';
+                if (this.options.includeSelectedText &&
+                    lastSelectedText !== currentSelectedText) {
+                    changes['selectionChanged'] = {
+                        path: currentActiveFile.path,
+                        selectedText: currentSelectedText,
+                    };
+                }
+            }
+        }
+        else if (lastActiveFile) {
+            changes['activeFileChanged'] = {
+                path: null,
+                previousPath: lastActiveFile.path,
+            };
+        }
+        if (Object.keys(changes).length === 0) {
+            return { contextParts: [], newIdeContext: currentIdeContext };
+        }
+        delta['changes'] = changes;
+        const jsonString = JSON.stringify(delta, null, 2);
+        const contextParts = [
+            "Here is a summary of changes in the user's editor context, in JSON format. This is for your information only.",
+            '```json',
+            jsonString,
+            '```',
+            "Don't acknowledge this context in your response unless specifically asked about it."
+        ];
+        return {
+            contextParts,
+            newIdeContext: currentIdeContext,
+        };
     }
     setForceFullContext(force) {
         this.forceFullContext = force;

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

@@ -11,5 +11,5 @@ export interface MemoryImportOptions {
 export declare class MemoryImportModifier extends BaseMessageModifier {
     private readonly options;
     constructor(options?: MemoryImportOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
 }

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

@@ -48,7 +48,8 @@ class MemoryImportModifier extends base_1.BaseMessageModifier {
             maxImports: options.maxImports || 10
         };
     }
-    async modify(originalRequest, createdMessage) {
+    async modify(_originalRequest, createdMessage) {
+        var _a, _b, _c, _d;
         try {
             if (!this.options.enableMemoryImport) {
                 return createdMessage;
@@ -64,21 +65,28 @@ class MemoryImportModifier extends base_1.BaseMessageModifier {
             const processedImports = [];
             let match;
             let importCount = 0;
-            while ((match = memoryImportPattern.exec(userMessage.content)) !== null && importCount < this.options.maxImports) {
+            const basePath = (_a = this.options.basePath) !== null && _a !== void 0 ? _a : process.cwd();
+            const maxImports = (_b = this.options.maxImports) !== null && _b !== void 0 ? _b : 10;
+            const maxFileSize = (_c = this.options.maxFileSize) !== null && _c !== void 0 ? _c : 1024 * 1024;
+            const allowedExtensions = (_d = this.options.allowedExtensions) !== null && _d !== void 0 ? _d : [];
+            while ((match = memoryImportPattern.exec(userMessage.content)) !== null && importCount < maxImports) {
                 const filePath = match[1];
-                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.options.basePath, filePath);
+                if (!filePath) {
+                    continue;
+                }
+                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(basePath, filePath);
                 try {
                     // Check if file exists and is allowed
                     const stats = await fs.promises.stat(fullPath);
                     if (!stats.isFile()) {
                         continue;
                     }
-                    if (stats.size > this.options.maxFileSize) {
+                    if (stats.size > maxFileSize) {
                         content = content.replace(match[0], `[File too large: ${filePath}]`);
                         continue;
                     }
                     const ext = path.extname(filePath);
-                    if (!this.options.allowedExtensions.includes(ext)) {
+                    if (!allowedExtensions.includes(ext)) {
                         content = content.replace(match[0], `[Unsupported file type: ${filePath}]`);
                         continue;
                     }

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

@@ -7,6 +7,11 @@ export interface ToolInjectionOptions {
     maxToolsInMessage?: number;
     giveToolExamples?: boolean;
     maxToolExamples?: number;
+    /**
+     * List of allowed tool names. If provided, only these tools will be available.
+     * If not provided, all tools will be available.
+     */
+    allowedTools?: string[];
 }
 export declare class ToolInjectionModifier extends BaseMessageModifier {
     private readonly options;

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

@@ -24,6 +24,10 @@ class ToolInjectionModifier extends base_1.BaseMessageModifier {
             let mentionedMCPs = originalRequest.mentionedMCPs || [];
             const { data: mentionedTools } = await codeboltjs_1.default.mcp.getTools(mentionedMCPs);
             tools = [...tools, ...(mentionedTools || [])];
+            // Filter tools if allowedTools is specified
+            if (this.options.allowedTools && this.options.allowedTools.length > 0) {
+                tools = tools.filter((tool) => this.options.allowedTools.includes(tool.function.name));
+            }
             if (tools.length === 0) {
                 return createdMessage;
             }

package/dist/processor-pieces/postInferenceProcessors/loopDetectionModifier.js

@@ -123,9 +123,13 @@ class LoopDetectionModifier extends base_1.BasePostInferenceProcessor {
         // Compare each message with every other message
         for (let i = 0; i < messages.length - 1; i++) {
             for (let j = i + 1; j < messages.length; j++) {
-                const similarity = this.calculateSimilarity(messages[i].content, messages[j].content);
-                if (similarity >= this.options.similarityThreshold) {
-                    return true;
+                const msgI = messages[i];
+                const msgJ = messages[j];
+                if (msgI && msgJ) {
+                    const similarity = this.calculateSimilarity(msgI.content, msgJ.content);
+                    if (similarity >= this.options.similarityThreshold) {
+                        return true;
+                    }
                 }
             }
         }
@@ -140,24 +144,36 @@ class LoopDetectionModifier extends base_1.BasePostInferenceProcessor {
         return 1 - (distance / maxLength);
     }
     levenshteinDistance(str1, str2) {
+        var _a, _b, _c, _d;
         const matrix = [];
         for (let i = 0; i <= str2.length; i++) {
             matrix[i] = [i];
         }
-        for (let j = 0; j <= str1.length; j++) {
-            matrix[0][j] = j;
+        const firstRow = matrix[0];
+        if (firstRow) {
+            for (let j = 0; j <= str1.length; j++) {
+                firstRow[j] = j;
+            }
         }
         for (let i = 1; i <= str2.length; i++) {
+            const currentRow = matrix[i];
+            const prevRow = matrix[i - 1];
+            if (!currentRow || !prevRow)
+                continue;
             for (let j = 1; j <= str1.length; j++) {
+                const prevDiag = (_a = prevRow[j - 1]) !== null && _a !== void 0 ? _a : 0;
+                const prevUp = (_b = prevRow[j]) !== null && _b !== void 0 ? _b : 0;
+                const prevLeft = (_c = currentRow[j - 1]) !== null && _c !== void 0 ? _c : 0;
                 if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
-                    matrix[i][j] = matrix[i - 1][j - 1];
+                    currentRow[j] = prevDiag;
                 }
                 else {
-                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                    currentRow[j] = Math.min(prevDiag + 1, prevLeft + 1, prevUp + 1);
                 }
             }
         }
-        return matrix[str2.length][str1.length];
+        const lastRow = matrix[str2.length];
+        return (_d = lastRow === null || lastRow === void 0 ? void 0 : lastRow[str1.length]) !== null && _d !== void 0 ? _d : 0;
     }
     cleanOldMessages(currentTime) {
         const cutoffTime = currentTime - this.options.timeWindowMs;