osagent-core 0.1.12

package/dist/src/utils/memoryImportProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryImportProcessor.js","sourceRoot":"","sources":["../../../src/utils/memoryImportProcessor.ts"],"names":[],"mappings":"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"}

package/dist/src/utils/memoryImportProcessor.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 OSAgent OC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/utils/memoryImportProcessor.test.js

@@ -0,0 +1,587 @@
+/**
+ * @license
+ * Copyright 2025 OSAgent OC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { marked } from 'marked';
+import { processImports, validateImportPath } from './memoryImportProcessor.js';
+// Helper function to create platform-agnostic test paths
+function testPath(...segments) {
+    // Start with the first segment as is (might be an absolute path on Windows)
+    let result = segments[0];
+    // Join remaining segments with the platform-specific separator
+    for (let i = 1; i < segments.length; i++) {
+        if (segments[i].startsWith('/') || segments[i].startsWith('\\')) {
+            // If segment starts with a separator, remove the trailing separator from the result
+            result = path.normalize(result.replace(/[\\/]+$/, '') + segments[i]);
+        }
+        else {
+            // Otherwise join with the platform separator
+            result = path.join(result, segments[i]);
+        }
+    }
+    return path.normalize(result);
+}
+vi.mock('fs/promises');
+const mockedFs = vi.mocked(fs);
+// Mock console methods to capture warnings
+const originalConsoleWarn = console.warn;
+const originalConsoleError = console.error;
+const originalConsoleDebug = console.debug;
+// Helper functions using marked for parsing and validation
+const parseMarkdown = (content) => marked.lexer(content);
+const findMarkdownComments = (content) => {
+    const tokens = parseMarkdown(content);
+    const comments = [];
+    function walkTokens(tokenList) {
+        for (const token of tokenList) {
+            const t = token;
+            if (t.type === 'html' && t.raw.includes('<!--')) {
+                comments.push(t.raw.trim());
+            }
+            if (t.tokens) {
+                walkTokens(t.tokens);
+            }
+        }
+    }
+    walkTokens(tokens);
+    return comments;
+};
+const findCodeBlocks = (content) => {
+    const tokens = parseMarkdown(content);
+    const codeBlocks = [];
+    function walkTokens(tokenList) {
+        for (const token of tokenList) {
+            const t = token;
+            if (t.type === 'code') {
+                codeBlocks.push({
+                    type: 'code_block',
+                    content: t.text,
+                });
+            }
+            else if (t.type === 'codespan') {
+                codeBlocks.push({
+                    type: 'inline_code',
+                    content: t.text,
+                });
+            }
+            if (t.tokens) {
+                walkTokens(t.tokens);
+            }
+        }
+    }
+    walkTokens(tokens);
+    return codeBlocks;
+};
+describe('memoryImportProcessor', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock console methods
+        console.warn = vi.fn();
+        console.error = vi.fn();
+        console.debug = vi.fn();
+    });
+    afterEach(() => {
+        // Restore console methods
+        console.warn = originalConsoleWarn;
+        console.error = originalConsoleError;
+        console.debug = originalConsoleDebug;
+    });
+    describe('processImports', () => {
+        it('should process basic md file imports', async () => {
+            const content = 'Some content @./test.md more content';
+            const basePath = testPath('test', 'path');
+            const importedContent = '# Imported Content\nThis is imported.';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile.mockResolvedValue(importedContent);
+            const result = await processImports(content, basePath, true);
+            // Use marked to find HTML comments (import markers)
+            const comments = findMarkdownComments(result.content);
+            expect(comments.some((c) => c.includes('Imported from: ./test.md'))).toBe(true);
+            expect(comments.some((c) => c.includes('End of import from: ./test.md'))).toBe(true);
+            // Verify the imported content is present
+            expect(result.content).toContain(importedContent);
+            // Verify the markdown structure is valid
+            const tokens = parseMarkdown(result.content);
+            expect(tokens).toBeDefined();
+            expect(tokens.length).toBeGreaterThan(0);
+            expect(mockedFs.readFile).toHaveBeenCalledWith(path.resolve(basePath, './test.md'), 'utf-8');
+        });
+        it('should import non-md files just like md files', async () => {
+            const content = 'Some content @./instructions.txt more content';
+            const basePath = testPath('test', 'path');
+            const importedContent = '# Instructions\nThis is a text file with markdown.';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile.mockResolvedValue(importedContent);
+            const result = await processImports(content, basePath, true);
+            // Use marked to find import comments
+            const comments = findMarkdownComments(result.content);
+            expect(comments.some((c) => c.includes('Imported from: ./instructions.txt'))).toBe(true);
+            expect(comments.some((c) => c.includes('End of import from: ./instructions.txt'))).toBe(true);
+            // Use marked to parse and validate the imported content structure
+            const tokens = parseMarkdown(result.content);
+            // Find headers in the parsed content
+            const headers = tokens.filter((token) => token.type === 'heading');
+            expect(headers.some((h) => h.text === 'Instructions')).toBe(true);
+            // Verify the imported content is present
+            expect(result.content).toContain(importedContent);
+            expect(console.warn).not.toHaveBeenCalled();
+            expect(mockedFs.readFile).toHaveBeenCalledWith(path.resolve(basePath, './instructions.txt'), 'utf-8');
+        });
+        it('should handle circular imports', async () => {
+            const content = 'Content @./circular.md more content';
+            const basePath = testPath('test', 'path');
+            const circularContent = 'Circular @./main.md content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile.mockResolvedValue(circularContent);
+            // Set up the import state to simulate we're already processing main.md
+            const importState = {
+                processedFiles: new Set(),
+                maxDepth: 10,
+                currentDepth: 0,
+                currentFile: testPath('test', 'path', 'main.md'), // Simulate we're processing main.md
+            };
+            const result = await processImports(content, basePath, true, importState);
+            // The circular import should be detected when processing the nested import
+            expect(result.content).toContain('<!-- File already processed: ./main.md -->');
+        });
+        it('should handle file not found errors', async () => {
+            const content = 'Content @./nonexistent.md more content';
+            const basePath = testPath('test', 'path');
+            mockedFs.access.mockRejectedValue(new Error('File not found'));
+            const result = await processImports(content, basePath, true);
+            expect(result.content).toContain('<!-- Import failed: ./nonexistent.md - File not found -->');
+            expect(console.error).toHaveBeenCalledWith('[ERROR] [ImportProcessor]', 'Failed to import ./nonexistent.md: File not found');
+        });
+        it('should respect max depth limit', async () => {
+            const content = 'Content @./deep.md more content';
+            const basePath = testPath('test', 'path');
+            const deepContent = 'Deep @./deeper.md content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile.mockResolvedValue(deepContent);
+            const importState = {
+                processedFiles: new Set(),
+                maxDepth: 1,
+                currentDepth: 1,
+            };
+            const result = await processImports(content, basePath, true, importState);
+            expect(console.warn).toHaveBeenCalledWith('[WARN] [ImportProcessor]', 'Maximum import depth (1) reached. Stopping import processing.');
+            expect(result.content).toBe(content);
+        });
+        it('should handle nested imports recursively', async () => {
+            const content = 'Main @./nested.md content';
+            const basePath = testPath('test', 'path');
+            const nestedContent = 'Nested @./inner.md content';
+            const innerContent = 'Inner content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(nestedContent)
+                .mockResolvedValueOnce(innerContent);
+            const result = await processImports(content, basePath, true);
+            expect(result.content).toContain('<!-- Imported from: ./nested.md -->');
+            expect(result.content).toContain('<!-- Imported from: ./inner.md -->');
+            expect(result.content).toContain(innerContent);
+        });
+        it('should handle absolute paths in imports', async () => {
+            const content = 'Content @/absolute/path/file.md more content';
+            const basePath = testPath('test', 'path');
+            const importedContent = 'Absolute path content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile.mockResolvedValue(importedContent);
+            const result = await processImports(content, basePath, true);
+            expect(result.content).toContain('<!-- Import failed: /absolute/path/file.md - Path traversal attempt -->');
+        });
+        it('should handle multiple imports in same content', async () => {
+            const content = 'Start @./first.md middle @./second.md end';
+            const basePath = testPath('test', 'path');
+            const firstContent = 'First content';
+            const secondContent = 'Second content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(firstContent)
+                .mockResolvedValueOnce(secondContent);
+            const result = await processImports(content, basePath, true);
+            expect(result.content).toContain('<!-- Imported from: ./first.md -->');
+            expect(result.content).toContain('<!-- Imported from: ./second.md -->');
+            expect(result.content).toContain(firstContent);
+            expect(result.content).toContain(secondContent);
+        });
+        it('should ignore imports inside code blocks', async () => {
+            const content = [
+                'Normal content @./should-import.md',
+                '```',
+                'code block with @./should-not-import.md',
+                '```',
+                'More content @./should-import2.md',
+            ].join('\n');
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const importedContent1 = 'Imported 1';
+            const importedContent2 = 'Imported 2';
+            // Only the imports outside code blocks should be processed
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(importedContent1)
+                .mockResolvedValueOnce(importedContent2);
+            const result = await processImports(content, basePath, true, undefined, projectRoot);
+            // Use marked to verify imported content is present
+            expect(result.content).toContain(importedContent1);
+            expect(result.content).toContain(importedContent2);
+            // Use marked to find code blocks and verify the import wasn't processed
+            const codeBlocks = findCodeBlocks(result.content);
+            const hasUnprocessedImport = codeBlocks.some((block) => block.content.includes('@./should-not-import.md'));
+            expect(hasUnprocessedImport).toBe(true);
+            // Verify no import comment was created for the code block import
+            const comments = findMarkdownComments(result.content);
+            expect(comments.some((c) => c.includes('should-not-import.md'))).toBe(false);
+        });
+        it('should ignore imports inside inline code', async () => {
+            const content = [
+                'Normal content @./should-import.md',
+                '`code with import @./should-not-import.md`',
+                'More content @./should-import2.md',
+            ].join('\n');
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const importedContent1 = 'Imported 1';
+            const importedContent2 = 'Imported 2';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(importedContent1)
+                .mockResolvedValueOnce(importedContent2);
+            const result = await processImports(content, basePath, true, undefined, projectRoot);
+            // Verify imported content is present
+            expect(result.content).toContain(importedContent1);
+            expect(result.content).toContain(importedContent2);
+            // Use marked to find inline code spans
+            const codeBlocks = findCodeBlocks(result.content);
+            const inlineCodeSpans = codeBlocks.filter((block) => block.type === 'inline_code');
+            // Verify the inline code span still contains the unprocessed import
+            expect(inlineCodeSpans.some((span) => span.content.includes('@./should-not-import.md'))).toBe(true);
+            // Verify no import comments were created for inline code imports
+            const comments = findMarkdownComments(result.content);
+            expect(comments.some((c) => c.includes('should-not-import.md'))).toBe(false);
+        });
+        it('should handle nested tokens and non-unique content correctly', async () => {
+            // This test verifies the robust findCodeRegions implementation
+            // that recursively walks the token tree and handles non-unique content
+            const content = [
+                'Normal content @./should-import.md',
+                'Paragraph with `inline code @./should-not-import.md` and more text.',
+                'Another paragraph with the same `inline code @./should-not-import.md` text.',
+                'More content @./should-import2.md',
+            ].join('\n');
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const importedContent1 = 'Imported 1';
+            const importedContent2 = 'Imported 2';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(importedContent1)
+                .mockResolvedValueOnce(importedContent2);
+            const result = await processImports(content, basePath, true, undefined, projectRoot);
+            // Should process imports outside code regions
+            expect(result.content).toContain(importedContent1);
+            expect(result.content).toContain(importedContent2);
+            // Should preserve imports inside inline code (both occurrences)
+            expect(result.content).toContain('`inline code @./should-not-import.md`');
+            // Should not have processed the imports inside code regions
+            expect(result.content).not.toContain('<!-- Imported from: ./should-not-import.md -->');
+        });
+        it('should not process imports in repeated inline code blocks', async () => {
+            const content = '`@noimport` and `@noimport`';
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const result = await processImports(content, basePath, true, undefined, projectRoot);
+            expect(result.content).toBe(content);
+        });
+        it('should not import when @ is inside an inline code block', async () => {
+            const content = 'We should not ` @import` when the symbol is inside an inline code string.';
+            const testRootDir = testPath('test', 'project');
+            const result = await processImports(content, testRootDir);
+            expect(result.content).toBe(content);
+            expect(result.importTree.imports).toBeUndefined();
+        });
+        it('should allow imports from parent and subdirectories within project root', async () => {
+            const content = 'Parent import: @../parent.md Subdir import: @./components/sub.md';
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const importedParent = 'Parent file content';
+            const importedSub = 'Subdir file content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(importedParent)
+                .mockResolvedValueOnce(importedSub);
+            const result = await processImports(content, basePath, true, undefined, projectRoot);
+            expect(result.content).toContain(importedParent);
+            expect(result.content).toContain(importedSub);
+        });
+        it('should reject imports outside project root', async () => {
+            const content = 'Outside import: @../../../etc/passwd';
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const result = await processImports(content, basePath, true, undefined, projectRoot);
+            expect(result.content).toContain('<!-- Import failed: ../../../etc/passwd - Path traversal attempt -->');
+        });
+        it('should build import tree structure', async () => {
+            const content = 'Main content @./nested.md @./simple.md';
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const nestedContent = 'Nested @./inner.md content';
+            const simpleContent = 'Simple content';
+            const innerContent = 'Inner content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(nestedContent)
+                .mockResolvedValueOnce(simpleContent)
+                .mockResolvedValueOnce(innerContent);
+            const result = await processImports(content, basePath, true);
+            // Use marked to find and validate import comments
+            const comments = findMarkdownComments(result.content);
+            const importComments = comments.filter((c) => c.includes('Imported from:'));
+            expect(importComments.some((c) => c.includes('./nested.md'))).toBe(true);
+            expect(importComments.some((c) => c.includes('./simple.md'))).toBe(true);
+            expect(importComments.some((c) => c.includes('./inner.md'))).toBe(true);
+            // Use marked to validate the markdown structure is well-formed
+            const tokens = parseMarkdown(result.content);
+            expect(tokens).toBeDefined();
+            expect(tokens.length).toBeGreaterThan(0);
+            // Verify the content contains expected text using marked parsing
+            const textContent = tokens
+                .filter((token) => token.type === 'paragraph')
+                .map((token) => token.raw)
+                .join(' ');
+            expect(textContent).toContain('Main content');
+            expect(textContent).toContain('Nested');
+            expect(textContent).toContain('Simple content');
+            expect(textContent).toContain('Inner content');
+            // Verify import tree structure
+            expect(result.importTree.path).toBe('unknown'); // No currentFile set in test
+            expect(result.importTree.imports).toHaveLength(2);
+            // First import: nested.md
+            // Check that the paths match using includes to handle potential absolute/relative differences
+            const expectedNestedPath = testPath(projectRoot, 'src', 'nested.md');
+            expect(result.importTree.imports[0].path).toContain(expectedNestedPath);
+            expect(result.importTree.imports[0].imports).toHaveLength(1);
+            const expectedInnerPath = testPath(projectRoot, 'src', 'inner.md');
+            expect(result.importTree.imports[0].imports[0].path).toContain(expectedInnerPath);
+            expect(result.importTree.imports[0].imports[0].imports).toBeUndefined();
+            // Second import: simple.md
+            const expectedSimplePath = testPath(projectRoot, 'src', 'simple.md');
+            expect(result.importTree.imports[1].path).toContain(expectedSimplePath);
+            expect(result.importTree.imports[1].imports).toBeUndefined();
+        });
+        it('should produce flat output in Claude-style with unique files in order', async () => {
+            const content = 'Main @./nested.md content @./simple.md';
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const nestedContent = 'Nested @./inner.md content';
+            const simpleContent = 'Simple content';
+            const innerContent = 'Inner content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(nestedContent)
+                .mockResolvedValueOnce(simpleContent)
+                .mockResolvedValueOnce(innerContent);
+            const result = await processImports(content, basePath, true, undefined, projectRoot, 'flat');
+            // Use marked to parse the output and validate structure
+            const tokens = parseMarkdown(result.content);
+            expect(tokens).toBeDefined();
+            // Find all file markers using marked parsing
+            const fileMarkers = [];
+            const endMarkers = [];
+            function walkTokens(tokenList) {
+                for (const token of tokenList) {
+                    const t = token;
+                    if (t.type === 'paragraph' && t.raw.includes('--- File:')) {
+                        const match = t.raw.match(/--- File: (.+?) ---/);
+                        if (match) {
+                            // Normalize the path before adding to fileMarkers
+                            fileMarkers.push(path.normalize(match[1]));
+                        }
+                    }
+                    if (t.type === 'paragraph' && t.raw.includes('--- End of File:')) {
+                        const match = t.raw.match(/--- End of File: (.+?) ---/);
+                        if (match) {
+                            // Normalize the path before adding to endMarkers
+                            endMarkers.push(path.normalize(match[1]));
+                        }
+                    }
+                    if (t.tokens) {
+                        walkTokens(t.tokens);
+                    }
+                }
+            }
+            walkTokens(tokens);
+            // Verify all expected files are present
+            const expectedFiles = ['nested.md', 'simple.md', 'inner.md'];
+            // Check that each expected file is present in the content
+            expectedFiles.forEach((file) => {
+                expect(result.content).toContain(file);
+            });
+            // Verify content is present
+            expect(result.content).toContain('Main @./nested.md content @./simple.md');
+            expect(result.content).toContain('Nested @./inner.md content');
+            expect(result.content).toContain('Simple content');
+            expect(result.content).toContain('Inner content');
+            // Verify end markers exist
+            expect(endMarkers.length).toBeGreaterThan(0);
+        });
+        it('should not duplicate files in flat output if imported multiple times', async () => {
+            const content = 'Main @./dup.md again @./dup.md';
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const dupContent = 'Duplicated content';
+            // Reset mocks
+            mockedFs.access.mockReset();
+            mockedFs.readFile.mockReset();
+            // Set up mocks
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile.mockResolvedValue(dupContent);
+            const result = await processImports(content, basePath, true, // followImports
+            undefined, // allowedPaths
+            projectRoot, 'flat');
+            // Verify readFile was called only once for dup.md
+            expect(mockedFs.readFile).toHaveBeenCalledTimes(1);
+            // Check that the content contains the file content only once
+            const contentStr = result.content;
+            const firstIndex = contentStr.indexOf('Duplicated content');
+            const lastIndex = contentStr.lastIndexOf('Duplicated content');
+            expect(firstIndex).toBeGreaterThan(-1); // Content should exist
+            expect(firstIndex).toBe(lastIndex); // Should only appear once
+        });
+        it('should handle nested imports in flat output', async () => {
+            const content = 'Root @./a.md';
+            const projectRoot = testPath('test', 'project');
+            const basePath = testPath(projectRoot, 'src');
+            const aContent = 'A @./b.md';
+            const bContent = 'B content';
+            mockedFs.access.mockResolvedValue(undefined);
+            mockedFs.readFile
+                .mockResolvedValueOnce(aContent)
+                .mockResolvedValueOnce(bContent);
+            const result = await processImports(content, basePath, true, undefined, projectRoot, 'flat');
+            // Verify all files are present by checking for their basenames
+            expect(result.content).toContain('a.md');
+            expect(result.content).toContain('b.md');
+            // Verify content is in the correct order
+            const contentStr = result.content;
+            const aIndex = contentStr.indexOf('a.md');
+            const bIndex = contentStr.indexOf('b.md');
+            const rootIndex = contentStr.indexOf('Root @./a.md');
+            expect(rootIndex).toBeLessThan(aIndex);
+            expect(aIndex).toBeLessThan(bIndex);
+            // Verify content is present
+            expect(result.content).toContain('Root @./a.md');
+            expect(result.content).toContain('A @./b.md');
+            expect(result.content).toContain('B content');
+        });
+    });
+    describe('validateImportPath', () => {
+        it('should reject URLs', () => {
+            const basePath = testPath('base');
+            const allowedPath = testPath('allowed');
+            expect(validateImportPath('https://example.com/file.md', basePath, [
+                allowedPath,
+            ])).toBe(false);
+            expect(validateImportPath('http://example.com/file.md', basePath, [
+                allowedPath,
+            ])).toBe(false);
+            expect(validateImportPath('file:///path/to/file.md', basePath, [allowedPath])).toBe(false);
+        });
+        it('should allow paths within allowed directories', () => {
+            const basePath = path.resolve(testPath('base'));
+            const allowedPath = path.resolve(testPath('allowed'));
+            // Test relative paths - resolve them against basePath
+            const relativePath = './file.md';
+            path.resolve(basePath, relativePath);
+            expect(validateImportPath(relativePath, basePath, [basePath])).toBe(true);
+            // Test parent directory access (should be allowed if parent is in allowed paths)
+            const parentPath = path.dirname(basePath);
+            if (parentPath !== basePath) {
+                // Only test if parent is different
+                const parentRelativePath = '../file.md';
+                path.resolve(basePath, parentRelativePath);
+                expect(validateImportPath(parentRelativePath, basePath, [parentPath])).toBe(true);
+                path.resolve(basePath, 'sub');
+                const resultSub = validateImportPath('sub', basePath, [basePath]);
+                expect(resultSub).toBe(true);
+            }
+            // Test allowed path access - use a file within the allowed directory
+            const allowedSubPath = 'nested';
+            const allowedFilePath = path.join(allowedPath, allowedSubPath, 'file.md');
+            expect(validateImportPath(allowedFilePath, basePath, [allowedPath])).toBe(true);
+        });
+        it('should reject paths outside allowed directories', () => {
+            const basePath = path.resolve(testPath('base'));
+            const allowedPath = path.resolve(testPath('allowed'));
+            const forbiddenPath = path.resolve(testPath('forbidden'));
+            // Forbidden path should be blocked
+            expect(validateImportPath(forbiddenPath, basePath, [allowedPath])).toBe(false);
+            // Relative path to forbidden directory should be blocked
+            const relativeToForbidden = path.relative(basePath, path.join(forbiddenPath, 'file.md'));
+            expect(validateImportPath(relativeToForbidden, basePath, [allowedPath])).toBe(false);
+            // Path that tries to escape the base directory should be blocked
+            const escapingPath = path.join('..', '..', 'sensitive', 'file.md');
+            expect(validateImportPath(escapingPath, basePath, [basePath])).toBe(false);
+        });
+        it('should handle multiple allowed directories', () => {
+            const basePath = path.resolve(testPath('base'));
+            const allowed1 = path.resolve(testPath('allowed1'));
+            const allowed2 = path.resolve(testPath('allowed2'));
+            // File not in any allowed path
+            const otherPath = path.resolve(testPath('other', 'file.md'));
+            expect(validateImportPath(otherPath, basePath, [allowed1, allowed2])).toBe(false);
+            // File in first allowed path
+            const file1 = path.join(allowed1, 'nested', 'file.md');
+            expect(validateImportPath(file1, basePath, [allowed1, allowed2])).toBe(true);
+            // File in second allowed path
+            const file2 = path.join(allowed2, 'nested', 'file.md');
+            expect(validateImportPath(file2, basePath, [allowed1, allowed2])).toBe(true);
+            // Test with relative path to allowed directory
+            const relativeToAllowed1 = path.relative(basePath, file1);
+            expect(validateImportPath(relativeToAllowed1, basePath, [allowed1, allowed2])).toBe(true);
+        });
+        it('should handle relative paths correctly', () => {
+            const basePath = path.resolve(testPath('base'));
+            const parentPath = path.resolve(testPath('parent'));
+            // Current directory file access
+            expect(validateImportPath('file.md', basePath, [basePath])).toBe(true);
+            // Explicit current directory file access
+            expect(validateImportPath('./file.md', basePath, [basePath])).toBe(true);
+            // Parent directory access - should be blocked unless parent is in allowed paths
+            const parentFile = path.join(parentPath, 'file.md');
+            const relativeToParent = path.relative(basePath, parentFile);
+            expect(validateImportPath(relativeToParent, basePath, [basePath])).toBe(false);
+            // Parent directory access when parent is in allowed paths
+            expect(validateImportPath(relativeToParent, basePath, [basePath, parentPath])).toBe(true);
+            // Nested relative path
+            const nestedPath = path.join('nested', 'sub', 'file.md');
+            expect(validateImportPath(nestedPath, basePath, [basePath])).toBe(true);
+        });
+        it('should handle absolute paths correctly', () => {
+            const basePath = path.resolve(testPath('base'));
+            const allowedPath = path.resolve(testPath('allowed'));
+            const forbiddenPath = path.resolve(testPath('forbidden'));
+            // Allowed path should work - file directly in allowed directory
+            const allowedFilePath = path.join(allowedPath, 'file.md');
+            expect(validateImportPath(allowedFilePath, basePath, [allowedPath])).toBe(true);
+            // Allowed path should work - file in subdirectory of allowed directory
+            const allowedNestedPath = path.join(allowedPath, 'nested', 'file.md');
+            expect(validateImportPath(allowedNestedPath, basePath, [allowedPath])).toBe(true);
+            // Forbidden path should be blocked
+            const forbiddenFilePath = path.join(forbiddenPath, 'file.md');
+            expect(validateImportPath(forbiddenFilePath, basePath, [allowedPath])).toBe(false);
+            // Relative path to allowed directory should work
+            const relativeToAllowed = path.relative(basePath, allowedFilePath);
+            expect(validateImportPath(relativeToAllowed, basePath, [allowedPath])).toBe(true);
+            // Path that resolves to the same file but via different relative segments
+            const dotPath = path.join('.', '..', path.basename(allowedPath), 'file.md');
+            expect(validateImportPath(dotPath, basePath, [allowedPath])).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=memoryImportProcessor.test.js.map