@qodo/sdk 0.1.0

package/dist/mcp/servers/filesystem.js

@@ -0,0 +1,992 @@
+import * as fsSync from 'fs';
+import { promises as fs } from 'fs';
+import * as diff from 'diff';
+import * as path from 'path';
+import { canonicalizePathSync, normalizeDriveLetter } from '../../utils/index.js';
+const DEFAULT_MAX_DEPTH = 3;
+const DEFAULT_MAX_DIRECTORIES = 2000;
+const DEFAULT_EXCLUDED_DIRS = [
+    '.git',
+    'node_modules',
+    '.idea',
+    '.vscode',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.turbo',
+    '.cache',
+    'out',
+    'target',
+    'venv',
+    '.venv',
+];
+function matchesPattern(name, pattern) {
+    const lowerName = name.toLowerCase();
+    const lowerPattern = pattern.toLowerCase();
+    if (!lowerPattern) {
+        return false;
+    }
+    if (lowerPattern === '*') {
+        return true;
+    }
+    if (lowerPattern.includes('*')) {
+        const parts = lowerPattern.split('*').filter(Boolean);
+        let currentIndex = 0;
+        for (const part of parts) {
+            const index = lowerName.indexOf(part, currentIndex);
+            if (index === -1) {
+                return false;
+            }
+            currentIndex = index + part.length;
+        }
+        return true;
+    }
+    return lowerName === lowerPattern;
+}
+export class TextNotFoundError extends Error {
+    editIndex;
+    oldText;
+    constructor(message, editIndex, oldText) {
+        super(message);
+        this.name = 'TextNotFoundError';
+        this.editIndex = editIndex;
+        this.oldText = oldText;
+    }
+}
+export class FilesystemServerEnhanced {
+    name = "filesystem";
+    version = "1.0.0";
+    allowedDirectories = [];
+    sessionLog;
+    changeCounter = 0;
+    constructor(allowedDirectories = []) {
+        // Canonicalize the allowed directories up front so that different
+        // representations of the same physical path (e.g. Windows `subst`
+        // drives like `S:\\repo` vs `C:\\long\\path\\repo`) are treated as
+        // identical roots. This also normalizes Windows drive letters.
+        this.allowedDirectories = allowedDirectories.map(dir => canonicalizePathSync(dir));
+        this.sessionLog = {
+            sessionId: this.generateSessionId(),
+            startTime: new Date().toISOString(),
+            entries: []
+        };
+    }
+    async initialize() {
+        try {
+            // Validate that all allowed directories exist and are accessible
+            for (const dir of this.allowedDirectories) {
+                try {
+                    await fs.access(dir, fs.constants.R_OK);
+                }
+                catch (error) {
+                    console.warn(`Warning: Directory ${dir} is not accessible:`, error);
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            console.error("Failed to initialize filesystem server:", error);
+            return false;
+        }
+    }
+    async listTools() {
+        const tools = [
+            {
+                name: "read_files",
+                description: "Read the contents of one or more files, optionally selecting line ranges per file (range, head, tail). Returns the content of each file along with its path. If reading multiple files, failed reads for individual files won't stop the operation - you'll get results for the files that could be read successfully.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        paths: {
+                            type: "array",
+                            items: {
+                                oneOf: [
+                                    { type: "string" },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            path: { type: "string" },
+                                            startLine: { type: "number", description: "1-based inclusive start line for range selection" },
+                                            endLine: { type: "number", description: "1-based inclusive end line for range selection" },
+                                            head: { type: "number", description: "Number of lines from the beginning of the file" },
+                                            tail: { type: "number", description: "Number of lines from the end of the file" }
+                                        },
+                                        required: ["path"],
+                                        additionalProperties: false
+                                    }
+                                ]
+                            },
+                            description: "Array of file specs to read. Each item can be either a string path or an object with { path, startLine?, endLine?, head?, tail? } to select specific lines. Examples: ['src/index.ts', { path: 'README.md', head: 50 }, { path: 'logs/app.log', tail: 100 }, { path: 'src/app.ts', startLine: 120, endLine: 200 }]. Each item can have different ranges."
+                        }
+                    },
+                    required: ["paths"]
+                },
+                autoApproved: false
+            },
+            {
+                name: "write_file",
+                description: "Create a new file or completely overwrite an existing file with new content. Use with caution as it will overwrite existing files without warning. Handles text content with proper encoding.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Path where to create/write the file. Examples: 'src/components/Button.tsx', 'docs/README.md', 'config/settings.json', 'scripts/build.sh'"
+                        },
+                        content: {
+                            type: "string",
+                            description: "Content to write to the file. Examples: TypeScript component code, markdown documentation, JSON configuration, shell script commands"
+                        }
+                    },
+                    required: ["path", "content"]
+                },
+                autoApproved: false
+            },
+            {
+                name: "edit_file",
+                description: "Make precise line-based edits to a text file by replacing exact text matches. Each edit operation finds and replaces specific text sequences. Returns a git-style diff showing the changes made. Use this for targeted modifications rather than rewriting entire files.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Path to the file to edit. Examples: 'src/index.ts', 'package.json', 'README.md', 'config/app.json'"
+                        },
+                        edits: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    oldText: {
+                                        type: "string",
+                                        description: "Exact text to search for and replace - must match exactly including whitespace and line breaks. Examples: 'console.log(\"Hello World\");', 'const version = \"1.0.0\";', '# Old Title'"
+                                    },
+                                    newText: {
+                                        type: "string",
+                                        description: "Text to replace the oldText with. Examples: 'console.log(\"Hello Universe!\");', 'const version = \"1.1.0\";', '# New Improved Title'"
+                                    }
+                                },
+                                required: ["oldText", "newText"]
+                            },
+                            description: "Array of edit operations to perform. Each operation replaces oldText with newText. Multiple edits are applied in sequence. Examples: [{'oldText': 'const port = 3000;', 'newText': 'const port = process.env.PORT || 3000;'}] for single edit, [{'oldText': 'import React from \\'react\\';', 'newText': 'import React, { useState } from \\'react\\';'}, {'oldText': 'function App() {', 'newText': 'function App() {\\n  const [count, setCount] = useState(0);'}] for multiple edits"
+                        },
+                    },
+                    required: ["path", "edits"]
+                },
+                autoApproved: false
+            },
+            {
+                name: "create_directory",
+                description: "Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. If the directory already exists, this operation will succeed silently. Perfect for setting up directory structures for projects or ensuring required paths exist.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Path of the directory to create. Can be nested paths that will be created recursively. Examples: 'src/components', 'docs/api', 'tests/unit/helpers', 'build/assets/images'"
+                        }
+                    },
+                    required: ["path"]
+                },
+                autoApproved: false
+            },
+            {
+                name: "list_files_in_directories",
+                description: "List files and immediate subdirectories in one or more directories (non-recursive). Returns the direct children of each specified path, with each directory's contents clearly labeled and files/directories distinguished with [FILE] and [DIR] prefixes. If listing multiple directories, failed reads for individual directories won't stop the operation - you'll get results for the directories that could be read successfully. Typically, you should call directory_tree with a shallow depth before using this tool to get an overview of the directory layout.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        paths: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of directory paths to list. Examples: ['.', 'src'] for current and src directories, ['src/components', 'src/utils'] for multiple source folders, ['docs'] for single directory, ['config', 'scripts', 'tests'] for project organization folders"
+                        }
+                    },
+                    required: ["paths"]
+                },
+                autoApproved: true
+            },
+            {
+                name: "directory_tree",
+                description: "Get a recursive tree view of the folder structure only (directories, not files) as a JSON structure. Traversal is intentionally shallow and capped for performance on large repositories. Each directory entry includes 'name', 'type' (always 'directory'), and 'children' array containing subdirectories. The root object also includes a 'meta' field with truncation details (e.g. maxDepth, maxDirectories, excluded, truncated). Use this to understand the high-level directory hierarchy without file clutter.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Path of the directory to traverse recursively for folder structure. Examples: '.' for current directory structure, 'src' for source folder hierarchy, 'docs' for documentation folders, 'tests' for test directory structure"
+                        },
+                        maxDepth: {
+                            type: "number",
+                            description: "Maximum directory depth to traverse (1 = only this directory). Defaults to 3 if not provided."
+                        },
+                        maxDirectories: {
+                            type: "number",
+                            description: "Global cap on the total number of directories to include in the tree. Defaults to 2000 if not provided."
+                        },
+                        exclude: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Directory names or simple glob-like patterns to skip (e.g. 'node_modules', '.git'). Defaults to a built-in list of common build/output directories if not provided."
+                        }
+                    },
+                    required: ["path"]
+                },
+                autoApproved: true
+            },
+            {
+                name: "move_file",
+                description: "Move or rename files and directories. Can move files between directories and rename them in a single operation. If the destination exists, the operation will fail. Works across different directories and can be used for simple renaming within the same directory. Use this to reorganize project structure or rename files.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        source: {
+                            type: "string",
+                            description: "Source path of the file or directory to move/rename. Examples: 'src/oldComponent.tsx', 'docs/old-readme.md', 'temp/data.json', 'src/utils' (directory)"
+                        },
+                        destination: {
+                            type: "string",
+                            description: "Destination path where the file/directory should be moved or renamed to. Examples: 'src/components/NewComponent.tsx', 'docs/README.md', 'data/processed/data.json', 'src/shared/utils'"
+                        }
+                    },
+                    required: ["source", "destination"]
+                },
+                autoApproved: false
+            },
+            {
+                name: "get_file_info",
+                description: "Retrieve detailed metadata about a file or directory. Returns comprehensive information including size, creation time, last modified time, permissions, and type. This tool is perfect for understanding file characteristics without reading the actual content. Use this to check file properties, sizes, or modification dates.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Path to the file or directory to get information about. Examples: 'package.json', 'src/index.ts', 'docs' (directory), 'build/output.js', 'README.md'"
+                        }
+                    },
+                    required: ["path"]
+                },
+                autoApproved: true
+            },
+            {
+                name: "list_allowed_directories",
+                description: "Get the list of directories that the filesystem server is allowed to access. Use this tool to understand which directories are available for file operations before attempting to access files or directories. This helps you understand the scope of filesystem access and avoid permission errors.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    required: []
+                },
+                autoApproved: true
+            },
+            {
+                name: "delete_files",
+                description: "Delete files and/or directories simultaneously. Use with caution as this operation cannot be undone. For directories, this will recursively delete all contents. Failed deletions for individual files won't stop the entire operation - you'll get a report of what was successfully deleted and what failed.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        paths: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of file and directory paths to delete. Examples: ['temp/cache.json'] for single file, ['build', 'dist', 'node_modules/.cache'] for multiple directories, ['src/deprecated.ts', 'docs/old-guide.md'] for multiple files, ['logs/debug.log', 'logs/error.log'] for log files. Array examples: ['temp/cache.json'], ['build', 'dist'], ['src/deprecated.ts', 'docs/old-guide.md', 'temp/old-data.json']"
+                        }
+                    },
+                    required: ["paths"]
+                },
+                autoApproved: false
+            }
+        ];
+        return { tools };
+    }
+    async callTool(request, _extra) {
+        try {
+            switch (request.name) {
+                case "read_files":
+                    return await this.readMultipleFiles(request.arguments.paths);
+                case "write_file":
+                    return await this.writeFile(request.arguments.path, request.arguments.content);
+                case "edit_file":
+                    return await this.editFile(request.arguments.path, request.arguments.edits);
+                case "create_directory":
+                    return await this.createDirectory(request.arguments.path);
+                case "list_files_in_directories":
+                    return await this.listFilesInDirectories(request.arguments.paths);
+                case "directory_tree":
+                    return await this.directoryTree(request.arguments.path, request.arguments);
+                case "move_file":
+                    return await this.moveFile(request.arguments.source, request.arguments.destination);
+                case "get_file_info":
+                    return await this.getFileInfo(request.arguments.path);
+                case "list_allowed_directories":
+                    return await this.listAllowedDirectories();
+                case "delete_files":
+                    return await this.deleteMultipleFiles(request.arguments.paths);
+                default:
+                    throw new Error(`Unknown tool: ${request.name}`);
+            }
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    }
+    resolvePath(filePath) {
+        // If already absolute, just normalize
+        if (path.isAbsolute(filePath)) {
+            return path.resolve(filePath);
+        }
+        // Prefer the first validated allowed directory as the base for relative paths.
+        // BuiltInServers ensures this list is ordered as:
+        //   [executionCwd?, projectRoots..., process.cwd(), ...]
+        const baseDir = this.allowedDirectories[0] || normalizeDriveLetter(process.cwd());
+        return path.resolve(baseDir, filePath);
+    }
+    validatePath(filePath) {
+        // Resolve the path to get the absolute path and handle any relative path components
+        const resolvedPath = this.resolvePath(filePath);
+        // Check if the path is within any allowed directory (including the directory itself and all subdirectories)
+        const isAllowed = this.allowedDirectories.some(allowedDir => {
+            // Canonicalize the allowed root so that aliasing (e.g. Windows `subst`
+            // virtual drives or symlinks) does not break sandbox checks. This also
+            // normalizes drive letters.
+            const normalizedAllowedDir = canonicalizePathSync(allowedDir);
+            // For the target path we need to be careful with non-existent files on
+            // Windows subst/virtual drives. realpathSync will fail for a file that
+            // doesn't exist yet (e.g. a brand-new file to be created), but the
+            // parent directory *does* exist and can be canonicalized to the
+            // underlying physical path. To handle this, we canonicalize the parent
+            // directory when the full path does not exist and then re-join the
+            // basename so that paths like:
+            //   allowedDir = "S:\\repo" (subst of C:\\long\\path\\repo)
+            //   resolvedPath = "S:\\repo\\src\\newFile.ts" (not yet created)
+            // become:
+            //   normalizedAllowedDir = "C:\\long\\path\\repo"
+            //   normalizedResolvedPath = "C:\\long\\path\\repo\\src\\newFile.ts".
+            let normalizedResolvedPath;
+            try {
+                if (fsSync.existsSync(resolvedPath)) {
+                    normalizedResolvedPath = canonicalizePathSync(resolvedPath);
+                }
+                else {
+                    const parent = path.dirname(resolvedPath);
+                    const parentCanonical = canonicalizePathSync(parent);
+                    normalizedResolvedPath = normalizeDriveLetter(path.join(parentCanonical, path.basename(resolvedPath)));
+                }
+            }
+            catch {
+                normalizedResolvedPath = canonicalizePathSync(resolvedPath);
+            }
+            // Allow access to the allowed directory itself
+            if (normalizedResolvedPath === normalizedAllowedDir) {
+                return true;
+            }
+            // Allow access to any subdirectory or file within the allowed directory
+            // Use path.relative to check if the resolved path is within the allowed directory
+            const relativePath = path.relative(normalizedAllowedDir, normalizedResolvedPath);
+            // If the relative path doesn't start with '..' and isn't empty, it's within the allowed directory
+            return relativePath && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
+        });
+        if (!isAllowed) {
+            throw new Error(`Access denied: Path ${resolvedPath} is not within allowed directories`);
+        }
+        return resolvedPath;
+    }
+    generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    generateChangeId() {
+        this.changeCounter++;
+        return `change_${this.changeCounter.toString().padStart(4, '0')}`;
+    }
+    logChange(operation, path, details) {
+        // Check if there's already an entry for this file path
+        const existingEntryIndex = this.sessionLog.entries.findIndex(entry => entry.path === path);
+        if (existingEntryIndex !== -1) {
+            // Merge with existing entry
+            const existingEntry = this.sessionLog.entries[existingEntryIndex];
+            // Update timestamp to the latest operation
+            existingEntry.timestamp = new Date().toISOString();
+            // Merge operations based on type
+            if (operation === 'edit' && (existingEntry.operation === 'edit' || existingEntry.operation === 'write' || existingEntry.operation === 'create')) {
+                // For edit operations, we want to show the cumulative diff
+                existingEntry.operation = operation;
+                // Update with cumulative diff and edit count
+                existingEntry.details.diff = details.diff;
+                existingEntry.details.editCount = details.editCount;
+                // Keep the original content from the first operation
+                if (!existingEntry.details.originalContent && details.originalContent) {
+                    existingEntry.details.originalContent = details.originalContent;
+                }
+                // Update summary to show cumulative edits
+                const totalEdits = details.editCount || 1;
+                existingEntry.details.summary = `Applied ${totalEdits} edit${totalEdits > 1 ? 's' : ''} to file (cumulative)`;
+            }
+            else if (operation === 'write' && (existingEntry.operation === 'create' || existingEntry.operation === 'write' || existingEntry.operation === 'edit')) {
+                // Write operation overwrites everything, so replace the entry
+                existingEntry.operation = operation;
+                existingEntry.details = details;
+            }
+            else if (operation === 'create' && existingEntry.operation === 'delete') {
+                // Delete followed by create - treat as write
+                existingEntry.operation = 'write';
+                existingEntry.details = details;
+            }
+            else if (operation === 'delete') {
+                // Delete operation - replace the entry since file is gone
+                existingEntry.operation = operation;
+                existingEntry.details = details;
+            }
+            else if (operation === 'move') {
+                // Move operation - update the entry
+                existingEntry.operation = operation;
+                existingEntry.details = { ...existingEntry.details, ...details };
+            }
+            else {
+                // For other cases, just update the details
+                existingEntry.details = { ...existingEntry.details, ...details };
+                existingEntry.details.summary = this.mergeSummaries(existingEntry.details.summary, details.summary);
+            }
+        }
+        else {
+            // Create new entry
+            const entry = {
+                id: this.generateChangeId(),
+                timestamp: new Date().toISOString(),
+                operation,
+                path,
+                details
+            };
+            this.sessionLog.entries.push(entry);
+        }
+    }
+    mergeSummaries(existing, newSummary) {
+        // Create a combined summary that shows the progression
+        return `${existing} → ${newSummary}`;
+    }
+    async findRepositoryRoot(startPath) {
+        let currentPath = path.resolve(startPath);
+        // If startPath is a file, start from its directory
+        try {
+            const stat = await fs.stat(currentPath);
+            if (stat.isFile()) {
+                currentPath = path.dirname(currentPath);
+            }
+        }
+        catch {
+            // If we can't stat the path, assume it's a directory
+        }
+        // Traverse up the directory tree looking for .git
+        while (currentPath !== path.dirname(currentPath)) { // Stop at filesystem root
+            try {
+                const gitPath = path.join(currentPath, '.git');
+                await fs.access(gitPath);
+                return currentPath; // Found .git directory
+            }
+            catch {
+                // .git not found, continue up
+            }
+            currentPath = path.dirname(currentPath);
+        }
+        return null; // No repository root found
+    }
+    getRelativePathFromRepo(filePath, repoRoot) {
+        if (!repoRoot) {
+            return filePath; // Return original path if no repo root found
+        }
+        const relativePath = path.relative(repoRoot, filePath);
+        return relativePath || filePath;
+    }
+    async readMultipleFiles(fileSpecs) {
+        const results = [];
+        for (const spec of fileSpecs) {
+            const filePath = typeof spec === 'string' ? spec : spec.path;
+            try {
+                const validatedPath = this.validatePath(filePath);
+                const content = await fs.readFile(validatedPath, 'utf-8');
+                const lines = content.split(/\r?\n/);
+                let selectedContent = content;
+                let rangeApplied = { type: 'all', totalLines: lines.length };
+                if (typeof spec !== 'string') {
+                    const startProvided = typeof spec.startLine === 'number';
+                    const endProvided = typeof spec.endLine === 'number';
+                    const headProvided = typeof spec.head === 'number' && spec.head > 0;
+                    const tailProvided = typeof spec.tail === 'number' && spec.tail > 0;
+                    if (startProvided || endProvided) {
+                        const start = Math.max(1, Math.floor(startProvided ? spec.startLine : 1));
+                        const end = Math.max(1, Math.floor(endProvided ? spec.endLine : lines.length));
+                        const normalizedStart = Math.min(start, lines.length);
+                        const normalizedEnd = Math.min(Math.max(normalizedStart, end), lines.length);
+                        selectedContent = lines.slice(normalizedStart - 1, normalizedEnd).join('\n');
+                        rangeApplied = { type: 'range', startLine: normalizedStart, endLine: normalizedEnd, totalLines: lines.length };
+                    }
+                    else if (headProvided) {
+                        const count = Math.min(Math.floor(spec.head), lines.length);
+                        selectedContent = lines.slice(0, count).join('\n');
+                        rangeApplied = { type: 'head', head: count, totalLines: lines.length };
+                    }
+                    else if (tailProvided) {
+                        const count = Math.min(Math.floor(spec.tail), lines.length);
+                        selectedContent = lines.slice(Math.max(0, lines.length - count)).join('\n');
+                        rangeApplied = { type: 'tail', tail: count, totalLines: lines.length };
+                    }
+                }
+                results.push({ path: filePath, content: selectedContent, rangeApplied: rangeApplied.type === 'all' ? undefined : rangeApplied });
+            }
+            catch (error) {
+                results.push({ path: filePath, error: error.message });
+            }
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+            isError: false
+        };
+    }
+    async writeFile(filePath, content) {
+        const validatedPath = this.validatePath(filePath);
+        try {
+            // Check if file exists to determine if this is create or write
+            let isCreate = false;
+            let originalContent = '';
+            try {
+                originalContent = await fs.readFile(validatedPath, 'utf-8');
+            }
+            catch {
+                isCreate = true;
+            }
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(validatedPath), { recursive: true });
+            await fs.writeFile(validatedPath, content, 'utf-8');
+            // Generate patch for both create and write operations
+            const patch = diff.createPatch(filePath, originalContent, // Empty string for new files
+            content, isCreate ? 'new file' : 'original', isCreate ? 'created' : 'modified');
+            // Log the change with patch
+            this.logChange(isCreate ? 'create' : 'write', filePath, {
+                diff: patch,
+                size: Buffer.byteLength(content, 'utf-8'),
+                originalContent: isCreate ? '' : originalContent,
+                summary: isCreate
+                    ? `Created new file with ${content.split('\n').length} lines`
+                    : `Overwrote file with ${content.split('\n').length} lines`
+            });
+            // Find repository root and calculate relative path
+            const repoRoot = await this.findRepositoryRoot(validatedPath);
+            const relativePathFromRepo = this.getRelativePathFromRepo(validatedPath, repoRoot);
+            const extraContent = {
+                beforeContent: originalContent,
+                afterContent: content,
+                relativePath: relativePathFromRepo,
+                repositoryRoot: repoRoot
+            };
+            return {
+                content: [{ type: "text", text: `Successfully wrote file: ${filePath}` }],
+                extraContent: extraContent,
+                isError: false,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to write file ${filePath}: ${error.message}`);
+        }
+    }
+    static async createPatch(filePath, originalContent, modifiedContent) {
+        return diff.createPatch(filePath, originalContent, modifiedContent, '', '');
+    }
+    static async getDiff(filePath, edits) {
+        // Align preview path resolution with the runtime server behavior:
+        // prefer execution CWD / project roots when available, otherwise fall back
+        // to process.cwd()-relative resolution.
+        let resolvedPath = path.resolve(filePath);
+        if (!path.isAbsolute(filePath)) {
+            try {
+                const { SessionContext } = await import('../../session/SessionContext.js');
+                const session = SessionContext.getInstance();
+                const execCwd = session?.getExecutionCwd?.();
+                const roots = session?.getProjectRootPaths?.();
+                const baseDir = execCwd || (Array.isArray(roots) && roots.length > 0 ? roots[0] : process.cwd());
+                resolvedPath = path.resolve(baseDir, filePath);
+            }
+            catch {
+                // SessionContext not available (e.g., very early init); fall back to process.cwd
+                resolvedPath = path.resolve(filePath);
+            }
+        }
+        const originalContent = await fs.readFile(resolvedPath, 'utf-8');
+        let modifiedContent = originalContent;
+        // Apply edits
+        for (let i = 0; i < edits.length; i++) {
+            const edit = edits[i];
+            if (!modifiedContent.includes(edit.oldText)) {
+                throw new TextNotFoundError(`Text not found: "${edit.oldText}"`, i, edit.oldText);
+            }
+            modifiedContent = modifiedContent.replace(edit.oldText, edit.newText);
+        }
+        return diff.createPatch(filePath, originalContent, modifiedContent, '', '');
+    }
+    async editFile(filePath, edits) {
+        const validatedPath = this.validatePath(filePath);
+        try {
+            const currentContent = await fs.readFile(validatedPath, 'utf-8');
+            let modifiedContent = currentContent;
+            // Apply edits
+            for (let i = 0; i < edits.length; i++) {
+                const edit = edits[i];
+                if (!modifiedContent.includes(edit.oldText)) {
+                    throw new TextNotFoundError(`Text not found: "${edit.oldText}"`, i, edit.oldText);
+                }
+                modifiedContent = modifiedContent.replace(edit.oldText, edit.newText);
+            }
+            // Apply changes
+            await fs.writeFile(validatedPath, modifiedContent, 'utf-8');
+            // For logging, we need to determine the original content for cumulative diff
+            // Check if there's already an entry for this file to get the original content
+            const existingEntry = this.sessionLog.entries.find(entry => entry.path === filePath);
+            const originalContent = existingEntry?.details.originalContent || currentContent;
+            // Create diff from original content to final content
+            const cumulativeDiff = diff.createPatch(filePath, originalContent, modifiedContent, 'original', 'modified');
+            // Log the change with cumulative information
+            this.logChange('edit', filePath, {
+                diff: cumulativeDiff,
+                originalContent: originalContent,
+                editCount: (existingEntry?.details.editCount || 0) + 1,
+                summary: `Applied ${edits.length} edit${edits.length > 1 ? 's' : ''} to file`
+            });
+            // Return the current edit diff for immediate feedback
+            const currentDiff = diff.createPatch(filePath, currentContent, modifiedContent, '', '');
+            const repoRoot = await this.findRepositoryRoot(validatedPath);
+            const relativePathFromRepo = this.getRelativePathFromRepo(validatedPath, repoRoot);
+            const extraContent = {
+                beforeContent: currentContent,
+                afterContent: modifiedContent,
+                relativePath: relativePathFromRepo,
+                repositoryRoot: repoRoot
+            };
+            return {
+                content: [{ type: "text", text: `File edited successfully:\n\n${currentDiff}` }],
+                extraContent: extraContent,
+                isError: false
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to edit file ${filePath}: ${error.message}`);
+        }
+    }
+    async createDirectory(dirPath) {
+        const validatedPath = this.validatePath(dirPath);
+        try {
+            // Check if directory already exists
+            let alreadyExists = false;
+            try {
+                const stat = await fs.stat(validatedPath);
+                alreadyExists = stat.isDirectory();
+            }
+            catch {
+                // Directory doesn't exist, which is what we want
+            }
+            await fs.mkdir(validatedPath, { recursive: true });
+            // Log the change only if directory was actually created
+            if (!alreadyExists) {
+                this.logChange('mkdir', dirPath, {
+                    summary: `Created directory`
+                });
+            }
+            return {
+                content: [{ type: "text", text: `Successfully created directory: ${dirPath}` }],
+                isError: false
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to create directory ${dirPath}: ${error.message}`);
+        }
+    }
+    async listFilesInDirectories(dirPaths) {
+        const results = [];
+        const errors = [];
+        for (const dirPath of dirPaths) {
+            try {
+                const validatedPath = this.validatePath(dirPath);
+                const entries = await fs.readdir(validatedPath, { withFileTypes: true });
+                // Add directory header
+                results.push(`\n=== ${dirPath} ===`);
+                if (entries.length === 0) {
+                    results.push("(empty directory)");
+                }
+                else {
+                    const listing = entries.map(entry => {
+                        const prefix = entry.isDirectory() ? '[DIR]' : '[FILE]';
+                        return `${prefix} ${entry.name}`;
+                    }).join('\n');
+                    results.push(listing);
+                }
+            }
+            catch (error) {
+                errors.push(`Failed to list ${dirPath}: ${error.message}`);
+            }
+        }
+        // Combine results and errors
+        let finalText = results.join('\n');
+        if (errors.length > 0) {
+            finalText += '\n\n=== Errors ===\n' + errors.join('\n');
+        }
+        return {
+            content: [{ type: "text", text: finalText.trim() }],
+            isError: false
+        };
+    }
+    async directoryTree(dirPath, args) {
+        const validatedPath = this.validatePath(dirPath);
+        const options = {
+            maxDepth: typeof args?.maxDepth === 'number' && args.maxDepth > 0
+                ? Math.floor(args.maxDepth)
+                : DEFAULT_MAX_DEPTH,
+            maxDirectories: typeof args?.maxDirectories === 'number' && args.maxDirectories > 0
+                ? Math.floor(args.maxDirectories)
+                : DEFAULT_MAX_DIRECTORIES,
+            exclude: Array.isArray(args?.exclude) && args.exclude.length > 0
+                ? args.exclude.map((value) => typeof value === 'string' ? value : String(value))
+                : DEFAULT_EXCLUDED_DIRS,
+        };
+        const state = { directoriesVisited: 0, truncated: false };
+        try {
+            const tree = await this.buildDirectoryTree(validatedPath, options, 1, state);
+            const result = {
+                name: tree?.name ?? path.basename(validatedPath),
+                type: 'directory',
+                children: tree?.children ?? [],
+                meta: {
+                    truncated: state.truncated,
+                    maxDepth: options.maxDepth,
+                    maxDirectories: options.maxDirectories,
+                    excluded: options.exclude,
+                },
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                isError: false
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to build directory tree for ${dirPath}: ${error.message}`);
+        }
+    }
+    async buildDirectoryTree(dirPath, options, depth, state) {
+        const name = path.basename(dirPath);
+        // Exclude directories by name or simple pattern matching
+        if (options.exclude.some(pattern => matchesPattern(name, pattern))) {
+            return null;
+        }
+        let stat;
+        try {
+            stat = await fs.stat(dirPath);
+        }
+        catch {
+            // If we can't stat the path, mark as truncated and return an empty node
+            state.truncated = true;
+            return { name, type: 'directory', children: [] };
+        }
+        if (!stat.isDirectory()) {
+            // Not a directory; nothing to traverse
+            return null;
+        }
+        if (depth > options.maxDepth || state.directoriesVisited >= options.maxDirectories) {
+            state.truncated = true;
+            return { name, type: 'directory', children: [] };
+        }
+        state.directoriesVisited++;
+        let entries;
+        try {
+            entries = await fs.readdir(dirPath, { withFileTypes: true });
+        }
+        catch {
+            state.truncated = true;
+            return { name, type: 'directory', children: [] };
+        }
+        const children = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (state.directoriesVisited >= options.maxDirectories) {
+                state.truncated = true;
+                break;
+            }
+            const entryPath = path.join(dirPath, entry.name);
+            try {
+                const child = await this.buildDirectoryTree(entryPath, options, depth + 1, state);
+                if (child) {
+                    children.push(child);
+                }
+                if (state.truncated) {
+                    break;
+                }
+            }
+            catch {
+                // Skip directories we can't access
+            }
+        }
+        return { name, type: 'directory', children };
+    }
+    async moveFile(source, destination) {
+        const validatedSource = this.validatePath(source);
+        const validatedDestination = this.validatePath(destination);
+        try {
+            // Check if destination exists
+            try {
+                await fs.access(validatedDestination);
+                throw new Error(`Destination already exists: ${destination}`);
+            }
+            catch (error) {
+                // Good, destination doesn't exist
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+            // Ensure destination directory exists
+            await fs.mkdir(path.dirname(validatedDestination), { recursive: true });
+            await fs.rename(validatedSource, validatedDestination);
+            // Log the change
+            this.logChange('move', destination, {
+                oldPath: source,
+                summary: `Moved from ${source} to ${destination}`
+            });
+            return {
+                content: [{ type: "text", text: `Successfully moved ${source} to ${destination}` }],
+                isError: false
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to move ${source} to ${destination}: ${error.message}`);
+        }
+    }
+    async searchFilesRecursive(dirPath, pattern, excludePatterns) {
+        const results = [];
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(dirPath, entry.name);
+            // Check if entry matches exclude patterns
+            const shouldExclude = excludePatterns.some(excludePattern => {
+                return entry.name.toLowerCase().includes(excludePattern.toLowerCase());
+            });
+            if (shouldExclude) {
+                continue;
+            }
+            // Check if entry matches search pattern
+            if (entry.name.toLowerCase().includes(pattern.toLowerCase())) {
+                results.push(entryPath);
+            }
+            // Recursively search directories
+            if (entry.isDirectory()) {
+                try {
+                    const subResults = await this.searchFilesRecursive(entryPath, pattern, excludePatterns);
+                    results.push(...subResults);
+                }
+                catch (error) {
+                }
+            }
+        }
+        return results;
+    }
+    async getFileInfo(filePath) {
+        const validatedPath = this.validatePath(filePath);
+        try {
+            const stat = await fs.stat(validatedPath);
+            const fileInfo = {
+                name: path.basename(validatedPath),
+                type: stat.isDirectory() ? 'directory' : 'file',
+                size: stat.size,
+                modified: stat.mtime.toISOString(),
+                created: stat.birthtime.toISOString(),
+                permissions: '0' + (stat.mode & parseInt('777', 8)).toString(8)
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(fileInfo, null, 2) }],
+                isError: false
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get file info for ${filePath}: ${error.message}`);
+        }
+    }
+    async listAllowedDirectories() {
+        return {
+            content: [{ type: "text", text: JSON.stringify(this.allowedDirectories, null, 2) }],
+            isError: false
+        };
+    }
+    async deleteMultipleFiles(filePaths) {
+        const results = [];
+        let successCount = 0;
+        let errorCount = 0;
+        for (const filePath of filePaths) {
+            try {
+                const validatedPath = this.validatePath(filePath);
+                // Check if file/directory exists and get its info
+                const stat = await fs.stat(validatedPath);
+                const isDirectory = stat.isDirectory();
+                const itemType = isDirectory ? 'directory' : 'file';
+                // For directories, we need to use recursive removal
+                if (isDirectory) {
+                    await fs.rm(validatedPath, { recursive: true, force: true });
+                }
+                else {
+                    await fs.unlink(validatedPath);
+                }
+                // Log the change
+                this.logChange('delete', filePath, {
+                    summary: `Deleted ${itemType}: ${path.basename(filePath)}`
+                });
+                results.push({ path: filePath, success: true, itemType });
+                successCount++;
+            }
+            catch (error) {
+                let errorMessage = error.message;
+                if (error.code === 'ENOENT') {
+                    errorMessage = `File or directory not found: ${filePath}`;
+                }
+                results.push({ path: filePath, error: errorMessage });
+                errorCount++;
+            }
+        }
+        // Create summary message
+        const summary = `Deletion completed: ${successCount} successful, ${errorCount} failed out of ${filePaths.length} total items`;
+        const detailedResults = JSON.stringify(results, null, 2);
+        return {
+            content: [{ type: "text", text: `${summary}\n\nDetailed results:\n${detailedResults}` }],
+            isError: errorCount > 0 && successCount === 0 // Only mark as error if ALL deletions failed
+        };
+    }
+    getSessionLog() {
+        return this.sessionLog;
+    }
+    getSessionLogSummary() {
+        // Create a summary view that shows the final state of each file
+        return {
+            sessionId: this.sessionLog.sessionId,
+            startTime: this.sessionLog.startTime,
+            totalOperations: this.sessionLog.entries.length,
+            fileChanges: this.sessionLog.entries.map(entry => ({
+                path: entry.path,
+                operation: entry.operation,
+                timestamp: entry.timestamp,
+                summary: entry.details.summary,
+                editCount: entry.details.editCount,
+                hasOriginalContent: !!entry.details.originalContent,
+                diffPreview: entry.details.diff ? entry.details.diff.split('\n').slice(0, 10).join('\n') + (entry.details.diff.split('\n').length > 10 ? '\n...' : '') : undefined
+            }))
+        };
+    }
+    async clearSessionLog() {
+        try {
+            this.sessionLog = {
+                sessionId: this.generateSessionId(),
+                startTime: new Date().toISOString(),
+                entries: []
+            };
+            this.changeCounter = 0;
+        }
+        catch (error) {
+            throw new Error(`Failed to clear session log: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=filesystem.js.map