ai-mind-map 1.13.0 → 1.14.1

package/dist/tools/filesystem-tools.js

@@ -561,76 +561,79 @@ export function registerFilesystemTools(server, graph, config, estimator = defau
         }
     });
     // ── mindmap_project_summary ───────────────────────────────────
-    server.tool('mindmap_project_summary', 'Get a complete project overview in a single call — WITHOUT indexing. ' +
-        'Detects project type, counts files by language, builds a compact directory tree, ' +
-        'finds entry points, and reads key config files. Works instantly on any project.', {
-        projectPath: z.string().describe('Absolute path to the project root'),
-    }, async ({ projectPath }) => {
-        try {
-            if (!existsSync(projectPath)) {
-                return mcpText(fail(`Project path not found: ${projectPath}`));
-            }
-            const stat = statSync(projectPath);
-            if (!stat.isDirectory()) {
-                return mcpText(fail(`Not a directory: ${projectPath}`));
-            }
-            // Parse .gitignore for extra skip rules
-            const gitignoreNames = parseGitignoreSimple(join(projectPath, '.gitignore'));
-            // Walk the directory tree
-            const state = {
-                totalFiles: 0,
-                totalDirs: 0,
-                languages: {},
-                entryPoints: [],
-                entriesWalked: 0,
-                truncated: false,
-            };
-            walkDirectory(projectPath, projectPath, gitignoreNames, state);
-            // Sort languages by count (descending)
-            const sortedLanguages = {};
-            const langEntries = Object.entries(state.languages).sort((a, b) => b[1] - a[1]);
-            for (const [ext, count] of langEntries) {
-                sortedLanguages[ext] = count;
-            }
-            // Detect project type
-            const projectTypes = detectProjectType(projectPath);
-            // Derive project name
-            let projectName = basename(projectPath);
-            const pkgPath = join(projectPath, 'package.json');
-            if (existsSync(pkgPath)) {
-                try {
-                    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-                    if (pkg.name)
-                        projectName = pkg.name;
+    // CONSOLIDATED: mindmap_project_summary disabled to reduce schema payload
+    if (false) {
+        server.tool('mindmap_project_summary', 'Get a complete project overview in a single call — WITHOUT indexing. ' +
+            'Detects project type, counts files by language, builds a compact directory tree, ' +
+            'finds entry points, and reads key config files. Works instantly on any project.', {
+            projectPath: z.string().describe('Absolute path to the project root'),
+        }, async ({ projectPath }) => {
+            try {
+                if (!existsSync(projectPath)) {
+                    return mcpText(fail(`Project path not found: ${projectPath}`));
                 }
-                catch {
-                    // use directory name
+                const stat = statSync(projectPath);
+                if (!stat.isDirectory()) {
+                    return mcpText(fail(`Not a directory: ${projectPath}`));
+                }
+                // Parse .gitignore for extra skip rules
+                const gitignoreNames = parseGitignoreSimple(join(projectPath, '.gitignore'));
+                // Walk the directory tree
+                const state = {
+                    totalFiles: 0,
+                    totalDirs: 0,
+                    languages: {},
+                    entryPoints: [],
+                    entriesWalked: 0,
+                    truncated: false,
+                };
+                walkDirectory(projectPath, projectPath, gitignoreNames, state);
+                // Sort languages by count (descending)
+                const sortedLanguages = {};
+                const langEntries = Object.entries(state.languages).sort((a, b) => b[1] - a[1]);
+                for (const [ext, count] of langEntries) {
+                    sortedLanguages[ext] = count;
+                }
+                // Detect project type
+                const projectTypes = detectProjectType(projectPath);
+                // Derive project name
+                let projectName = basename(projectPath);
+                const pkgPath = join(projectPath, 'package.json');
+                if (existsSync(pkgPath)) {
+                    try {
+                        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                        if (pkg.name)
+                            projectName = pkg.name;
+                    }
+                    catch {
+                        // use directory name
+                    }
                 }
+                // Build compact directory tree
+                const directoryTree = buildCompactTree(projectPath, projectPath, gitignoreNames);
+                // Read config summaries
+                const configSummary = readConfigSummary(projectPath);
+                const result = {
+                    projectPath,
+                    projectName,
+                    projectType: projectTypes,
+                    totalFiles: state.totalFiles,
+                    totalDirs: state.totalDirs,
+                    languages: sortedLanguages,
+                    directoryTree: directoryTree || '(empty)',
+                    entryPoints: state.entryPoints,
+                    configSummary,
+                    estimatedIndexTime: estimateIndexTime(state.totalFiles),
+                    ...(state.truncated ? { truncated: true, note: `Scan capped at ${MAX_WALK_ENTRIES} entries` } : {}),
+                };
+                return mcpText(ok(result, estimator));
             }
-            // Build compact directory tree
-            const directoryTree = buildCompactTree(projectPath, projectPath, gitignoreNames);
-            // Read config summaries
-            const configSummary = readConfigSummary(projectPath);
-            const result = {
-                projectPath,
-                projectName,
-                projectType: projectTypes,
-                totalFiles: state.totalFiles,
-                totalDirs: state.totalDirs,
-                languages: sortedLanguages,
-                directoryTree: directoryTree || '(empty)',
-                entryPoints: state.entryPoints,
-                configSummary,
-                estimatedIndexTime: estimateIndexTime(state.totalFiles),
-                ...(state.truncated ? { truncated: true, note: `Scan capped at ${MAX_WALK_ENTRIES} entries` } : {}),
-            };
-            return mcpText(ok(result, estimator));
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return mcpText(fail(`Failed to generate project summary: ${msg}`));
-        }
-    });
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return mcpText(fail(`Failed to generate project summary: ${msg}`));
+            }
+        });
+    }
     // ── mindmap_grep ──────────────────────────────────────────────
     /** Detect binary files by checking for null bytes in the first 512 bytes */
     function isBinaryFile(filePath) {
@@ -679,135 +682,138 @@ export function registerFilesystemTools(server, graph, config, estimator = defau
             }
         }
     }
-    server.tool('mindmap_grep', 'Powerful text search across project files. Searches file contents for a pattern (literal or regex) with optional context lines, file filtering, and word-boundary matching. Like ripgrep but through MCP. Returns matching lines with file paths and line numbers.', {
-        pattern: z.string().describe('Search pattern (literal text or regex)'),
-        regex: z.boolean().default(false).describe('Treat pattern as regex'),
-        fileGlob: z.string().optional().describe("Filter by file extension pattern, e.g. '*.cs', '*.ts'"),
-        caseSensitive: z.boolean().default(false).describe('Case-sensitive matching'),
-        contextLines: z.number().int().min(0).max(5).default(0).describe('Lines of context before/after each match (max 5)'),
-        maxResults: z.number().int().min(1).default(100).describe('Maximum results to return'),
-        path: z.string().optional().describe('Search within a specific subdirectory (absolute or relative to projectRoot)'),
-        invertMatch: z.boolean().default(false).describe('Return lines that do NOT match'),
-        wholeWord: z.boolean().default(false).describe('Match whole words only'),
-    }, async ({ pattern, regex: isRegex, fileGlob, caseSensitive, contextLines, maxResults, path: subPath, invertMatch, wholeWord }) => {
-        try {
-            // Determine search root
-            let searchRoot = config.projectRoot;
-            if (subPath) {
-                const resolved = resolvePath(subPath, config.projectRoot, true);
-                if (!resolved) {
-                    return mcpText(fail(`Path "${subPath}" resolves outside the project root`));
+    // CONSOLIDATED: mindmap_grep disabled to reduce schema payload
+    if (false) {
+        server.tool('mindmap_grep', 'Powerful text search across project files. Searches file contents for a pattern (literal or regex) with optional context lines, file filtering, and word-boundary matching. Like ripgrep but through MCP. Returns matching lines with file paths and line numbers.', {
+            pattern: z.string().describe('Search pattern (literal text or regex)'),
+            regex: z.boolean().default(false).describe('Treat pattern as regex'),
+            fileGlob: z.string().optional().describe("Filter by file extension pattern, e.g. '*.cs', '*.ts'"),
+            caseSensitive: z.boolean().default(false).describe('Case-sensitive matching'),
+            contextLines: z.number().int().min(0).max(5).default(0).describe('Lines of context before/after each match (max 5)'),
+            maxResults: z.number().int().min(1).default(100).describe('Maximum results to return'),
+            path: z.string().optional().describe('Search within a specific subdirectory (absolute or relative to projectRoot)'),
+            invertMatch: z.boolean().default(false).describe('Return lines that do NOT match'),
+            wholeWord: z.boolean().default(false).describe('Match whole words only'),
+        }, async ({ pattern, regex: isRegex, fileGlob, caseSensitive, contextLines, maxResults, path: subPath, invertMatch, wholeWord }) => {
+            try {
+                // Determine search root
+                let searchRoot = config.projectRoot;
+                if (subPath) {
+                    const resolved = resolvePath(subPath, config.projectRoot, true);
+                    if (!resolved) {
+                        return mcpText(fail(`Path "${subPath}" resolves outside the project root`));
+                    }
+                    if (!existsSync(resolved)) {
+                        return mcpText(fail(`Path not found: ${resolved}`));
+                    }
+                    searchRoot = resolved;
                 }
-                if (!existsSync(resolved)) {
-                    return mcpText(fail(`Path not found: ${resolved}`));
+                // Build file glob regex
+                let globRegex = null;
+                if (fileGlob) {
+                    const escaped = fileGlob.replace(/[.+^${}()|[\]]/g, '\\$&');
+                    const globPattern = escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
+                    globRegex = new RegExp(`^${globPattern}$`, 'i');
                 }
-                searchRoot = resolved;
-            }
-            // Build file glob regex
-            let globRegex = null;
-            if (fileGlob) {
-                const escaped = fileGlob.replace(/[.+^${}()|[\]]/g, '\\$&');
-                const globPattern = escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
-                globRegex = new RegExp(`^${globPattern}$`, 'i');
-            }
-            // Build search regex
-            let searchPattern;
-            if (isRegex) {
-                searchPattern = pattern;
-            }
-            else {
-                searchPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            }
-            if (wholeWord) {
-                searchPattern = `\\b${searchPattern}\\b`;
-            }
-            const flags = caseSensitive ? 'g' : 'gi';
-            let searchRegex;
-            try {
-                searchRegex = new RegExp(searchPattern, flags);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return mcpText(fail(`Invalid regex pattern: ${msg}`));
-            }
-            // Collect files to search
-            const filePaths = [];
-            walkForGrep(searchRoot, globRegex, filePaths);
-            filePaths.sort();
-            // Search files
-            const results = [];
-            let totalMatches = 0;
-            const filesWithMatches = new Set();
-            let truncated = false;
-            for (const filePath of filePaths) {
-                if (results.length >= maxResults) {
-                    truncated = true;
-                    break;
+                // Build search regex
+                let searchPattern;
+                if (isRegex) {
+                    searchPattern = pattern;
                 }
-                // Skip large files
-                try {
-                    const stat = statSync(filePath);
-                    if (stat.size > MAX_GREP_FILE_SIZE)
-                        continue;
+                else {
+                    searchPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                 }
-                catch {
-                    continue;
+                if (wholeWord) {
+                    searchPattern = `\\b${searchPattern}\\b`;
                 }
-                // Skip binary files
-                if (isBinaryFile(filePath))
-                    continue;
-                let content;
+                const flags = caseSensitive ? 'g' : 'gi';
+                let searchRegex;
                 try {
-                    content = readFileSync(filePath, 'utf-8');
+                    searchRegex = new RegExp(searchPattern, flags);
                 }
-                catch {
-                    continue;
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return mcpText(fail(`Invalid regex pattern: ${msg}`));
                 }
-                const lines = content.split('\n');
-                const relativePath = relative(config.projectRoot, filePath).replace(/\\/g, '/');
-                for (let i = 0; i < lines.length; i++) {
+                // Collect files to search
+                const filePaths = [];
+                walkForGrep(searchRoot, globRegex, filePaths);
+                filePaths.sort();
+                // Search files
+                const results = [];
+                let totalMatches = 0;
+                const filesWithMatches = new Set();
+                let truncated = false;
+                for (const filePath of filePaths) {
                     if (results.length >= maxResults) {
                         truncated = true;
                         break;
                     }
-                    const line = lines[i];
-                    searchRegex.lastIndex = 0;
-                    const matches = line.match(searchRegex);
-                    const hasMatch = matches !== null && matches.length > 0;
-                    if (invertMatch ? !hasMatch : hasMatch) {
-                        const matchCount = invertMatch ? 0 : (matches?.length ?? 0);
-                        totalMatches += matchCount || 1;
-                        filesWithMatches.add(relativePath);
-                        const entry = {
-                            file: relativePath,
-                            line: line,
-                            lineNumber: i + 1,
-                            matchCount,
-                        };
-                        if (contextLines > 0) {
-                            const beforeStart = Math.max(0, i - contextLines);
-                            const afterEnd = Math.min(lines.length - 1, i + contextLines);
-                            entry.before = lines.slice(beforeStart, i);
-                            entry.after = lines.slice(i + 1, afterEnd + 1);
+                    // Skip large files
+                    try {
+                        const stat = statSync(filePath);
+                        if (stat.size > MAX_GREP_FILE_SIZE)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    // Skip binary files
+                    if (isBinaryFile(filePath))
+                        continue;
+                    let content;
+                    try {
+                        content = readFileSync(filePath, 'utf-8');
+                    }
+                    catch {
+                        continue;
+                    }
+                    const lines = content.split('\n');
+                    const relativePath = relative(config.projectRoot, filePath).replace(/\\/g, '/');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (results.length >= maxResults) {
+                            truncated = true;
+                            break;
+                        }
+                        const line = lines[i];
+                        searchRegex.lastIndex = 0;
+                        const matches = line.match(searchRegex);
+                        const hasMatch = matches !== null && matches.length > 0;
+                        if (invertMatch ? !hasMatch : hasMatch) {
+                            const matchCount = invertMatch ? 0 : (matches?.length ?? 0);
+                            totalMatches += matchCount || 1;
+                            filesWithMatches.add(relativePath);
+                            const entry = {
+                                file: relativePath,
+                                line: line,
+                                lineNumber: i + 1,
+                                matchCount,
+                            };
+                            if (contextLines > 0) {
+                                const beforeStart = Math.max(0, i - contextLines);
+                                const afterEnd = Math.min(lines.length - 1, i + contextLines);
+                                entry.before = lines.slice(beforeStart, i);
+                                entry.after = lines.slice(i + 1, afterEnd + 1);
+                            }
+                            results.push(entry);
                         }
-                        results.push(entry);
                     }
                 }
+                return mcpText(ok({
+                    pattern,
+                    totalMatches,
+                    totalFiles: filePaths.length,
+                    filesWithMatches: filesWithMatches.size,
+                    truncated,
+                    results,
+                }, estimator));
             }
-            return mcpText(ok({
-                pattern,
-                totalMatches,
-                totalFiles: filePaths.length,
-                filesWithMatches: filesWithMatches.size,
-                truncated,
-                results,
-            }, estimator));
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return mcpText(fail(`Grep failed: ${msg}`));
-        }
-    });
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return mcpText(fail(`Grep failed: ${msg}`));
+            }
+        });
+    }
     // ── mindmap_find_file ─────────────────────────────────────────
     /** Convert a glob pattern (with * and ?) to a RegExp */
     function globToRegex(glob) {
@@ -857,180 +863,259 @@ export function registerFilesystemTools(server, graph, config, estimator = defau
             return 60;
         return 40;
     }
-    server.tool('mindmap_find_file', 'Find files by name pattern across the project. Supports wildcards (* and ?) and regex. Searches indexed files first for instant results, falls back to filesystem walk. Returns paths sorted by relevance.', {
-        pattern: z.string().describe('Filename pattern to search for (supports wildcards: * and ?)'),
-        regex: z.boolean().default(false).describe('Treat pattern as regex instead of glob'),
-        type: z.enum(['file', 'dir', 'all']).default('file').describe("Filter by type: 'file', 'dir', or 'all'"),
-        maxDepth: z.number().int().min(1).default(20).describe('Maximum directory depth to search'),
-        maxResults: z.number().int().min(1).default(50).describe('Maximum results'),
-        path: z.string().optional().describe('Search within a specific subdirectory'),
-        includeSize: z.boolean().default(true).describe('Include file size in results'),
-        includeModified: z.boolean().default(false).describe('Include last modified timestamp'),
-        sortBy: z.enum(['relevance', 'name', 'size', 'modified']).default('relevance').describe("Sort by 'relevance', 'name', 'size', or 'modified'"),
-    }, async ({ pattern, regex: isRegex, type: filterType, maxDepth, maxResults, path: subPath, includeSize, includeModified, sortBy }) => {
-        try {
-            // Determine search root
-            let searchRoot = config.projectRoot;
-            if (subPath) {
-                const resolved = resolvePath(subPath, config.projectRoot, true);
-                if (!resolved) {
-                    return mcpText(fail(`Path "${subPath}" resolves outside the project root`));
-                }
-                if (!existsSync(resolved)) {
-                    return mcpText(fail(`Path not found: ${resolved}`));
-                }
-                searchRoot = resolved;
-            }
-            // Build match regex
-            let matchRegex;
+    // CONSOLIDATED: mindmap_find_file disabled to reduce schema payload
+    if (false) {
+        server.tool('mindmap_find_file', 'Find files by name pattern across the project. Supports wildcards (* and ?) and regex. Searches indexed files first for instant results, falls back to filesystem walk. Returns paths sorted by relevance.', {
+            pattern: z.string().describe('Filename pattern to search for (supports wildcards: * and ?)'),
+            regex: z.boolean().default(false).describe('Treat pattern as regex instead of glob'),
+            type: z.enum(['file', 'dir', 'all']).default('file').describe("Filter by type: 'file', 'dir', or 'all'"),
+            maxDepth: z.number().int().min(1).default(20).describe('Maximum directory depth to search'),
+            maxResults: z.number().int().min(1).default(50).describe('Maximum results'),
+            path: z.string().optional().describe('Search within a specific subdirectory'),
+            includeSize: z.boolean().default(true).describe('Include file size in results'),
+            includeModified: z.boolean().default(false).describe('Include last modified timestamp'),
+            sortBy: z.enum(['relevance', 'name', 'size', 'modified']).default('relevance').describe("Sort by 'relevance', 'name', 'size', or 'modified'"),
+        }, async ({ pattern, regex: isRegex, type: filterType, maxDepth, maxResults, path: subPath, includeSize, includeModified, sortBy }) => {
             try {
-                if (isRegex) {
-                    matchRegex = new RegExp(pattern, 'i');
-                }
-                else {
-                    matchRegex = globToRegex(pattern);
+                // Determine search root
+                let searchRoot = config.projectRoot;
+                if (subPath) {
+                    const resolved = resolvePath(subPath, config.projectRoot, true);
+                    if (!resolved) {
+                        return mcpText(fail(`Path "${subPath}" resolves outside the project root`));
+                    }
+                    if (!existsSync(resolved)) {
+                        return mcpText(fail(`Path not found: ${resolved}`));
+                    }
+                    searchRoot = resolved;
                 }
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return mcpText(fail(`Invalid pattern: ${msg}`));
-            }
-            // Try indexed files first (only if searching from project root and filterType includes files)
-            let candidates = [];
-            let usedIndex = false;
-            if (!subPath && (filterType === 'file' || filterType === 'all')) {
+                // Build match regex
+                let matchRegex;
                 try {
-                    const indexedFiles = graph.getIndexedFiles();
-                    if (indexedFiles && indexedFiles.length > 0) {
-                        usedIndex = true;
-                        for (const filePath of indexedFiles) {
-                            candidates.push({
-                                path: filePath,
-                                name: basename(filePath),
-                                type: 'file',
-                            });
-                        }
+                    if (isRegex) {
+                        matchRegex = new RegExp(pattern, 'i');
+                    }
+                    else {
+                        matchRegex = globToRegex(pattern);
                     }
                 }
-                catch {
-                    // Graph not ready, fall through to filesystem walk
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return mcpText(fail(`Invalid pattern: ${msg}`));
                 }
-            }
-            // Fallback to filesystem walk if no indexed files or path specified
-            if (!usedIndex) {
-                walkForFind(searchRoot, filterType, maxDepth, candidates);
-            }
-            // Filter by pattern
-            const matched = [];
-            for (const candidate of candidates) {
-                if (matchRegex.test(candidate.name)) {
-                    const relativePath = relative(config.projectRoot, candidate.path).replace(/\\/g, '/');
-                    const entry = {
-                        path: candidate.path,
-                        relativePath,
-                        name: candidate.name,
-                        type: candidate.type,
-                        score: scoreMatch(candidate.name, pattern),
-                    };
-                    if (includeSize || includeModified || sortBy === 'size' || sortBy === 'modified') {
-                        try {
-                            const st = statSync(candidate.path);
-                            if (includeSize)
-                                entry.sizeBytes = st.size;
-                            if (includeModified)
-                                entry.modifiedAt = st.mtime.toISOString();
-                            // Store for sorting even if not included in output
-                            if (sortBy === 'size' && !includeSize)
-                                entry.sizeBytes = st.size;
-                            if (sortBy === 'modified' && !includeModified)
-                                entry.modifiedAt = st.mtime.toISOString();
+                // Try indexed files first (only if searching from project root and filterType includes files)
+                let candidates = [];
+                let usedIndex = false;
+                if (!subPath && (filterType === 'file' || filterType === 'all')) {
+                    try {
+                        const indexedFiles = graph.getIndexedFiles();
+                        if (indexedFiles && indexedFiles.length > 0) {
+                            usedIndex = true;
+                            for (const filePath of indexedFiles) {
+                                candidates.push({
+                                    path: filePath,
+                                    name: basename(filePath),
+                                    type: 'file',
+                                });
+                            }
                         }
-                        catch {
-                            // Can't stat — skip size/modified
+                    }
+                    catch {
+                        // Graph not ready, fall through to filesystem walk
+                    }
+                }
+                // Fallback to filesystem walk if no indexed files or path specified
+                if (!usedIndex) {
+                    walkForFind(searchRoot, filterType, maxDepth, candidates);
+                }
+                // Filter by pattern
+                const matched = [];
+                for (const candidate of candidates) {
+                    if (matchRegex.test(candidate.name)) {
+                        const relativePath = relative(config.projectRoot, candidate.path).replace(/\\/g, '/');
+                        const entry = {
+                            path: candidate.path,
+                            relativePath,
+                            name: candidate.name,
+                            type: candidate.type,
+                            score: scoreMatch(candidate.name, pattern),
+                        };
+                        if (includeSize || includeModified || sortBy === 'size' || sortBy === 'modified') {
+                            try {
+                                const st = statSync(candidate.path);
+                                if (includeSize)
+                                    entry.sizeBytes = st.size;
+                                if (includeModified)
+                                    entry.modifiedAt = st.mtime.toISOString();
+                                // Store for sorting even if not included in output
+                                if (sortBy === 'size' && !includeSize)
+                                    entry.sizeBytes = st.size;
+                                if (sortBy === 'modified' && !includeModified)
+                                    entry.modifiedAt = st.mtime.toISOString();
+                            }
+                            catch {
+                                // Can't stat — skip size/modified
+                            }
                         }
+                        matched.push(entry);
                     }
-                    matched.push(entry);
                 }
-            }
-            // Sort results
-            matched.sort((a, b) => {
-                switch (sortBy) {
-                    case 'name':
-                        return a.name.localeCompare(b.name);
-                    case 'size':
-                        return (b.sizeBytes ?? 0) - (a.sizeBytes ?? 0);
-                    case 'modified':
-                        return (b.modifiedAt ?? '').localeCompare(a.modifiedAt ?? '');
-                    case 'relevance':
-                    default: {
-                        if (a.score !== b.score)
-                            return b.score - a.score;
-                        return a.name.localeCompare(b.name);
+                // Sort results
+                matched.sort((a, b) => {
+                    switch (sortBy) {
+                        case 'name':
+                            return a.name.localeCompare(b.name);
+                        case 'size':
+                            return (b.sizeBytes ?? 0) - (a.sizeBytes ?? 0);
+                        case 'modified':
+                            return (b.modifiedAt ?? '').localeCompare(a.modifiedAt ?? '');
+                        case 'relevance':
+                        default: {
+                            if (a.score !== b.score)
+                                return b.score - a.score;
+                            return a.name.localeCompare(b.name);
+                        }
                     }
+                });
+                const truncated = matched.length > maxResults;
+                const results = matched.slice(0, maxResults);
+                // Clean up internal-only sort fields if not requested
+                if (!includeSize) {
+                    for (const r of results)
+                        delete r.sizeBytes;
+                }
+                if (!includeModified) {
+                    for (const r of results)
+                        delete r.modifiedAt;
                 }
-            });
-            const truncated = matched.length > maxResults;
-            const results = matched.slice(0, maxResults);
-            // Clean up internal-only sort fields if not requested
-            if (!includeSize) {
-                for (const r of results)
-                    delete r.sizeBytes;
+                return mcpText(ok({
+                    pattern,
+                    totalResults: matched.length,
+                    truncated,
+                    results,
+                }, estimator));
             }
-            if (!includeModified) {
-                for (const r of results)
-                    delete r.modifiedAt;
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return mcpText(fail(`Find file failed: ${msg}`));
             }
-            return mcpText(ok({
-                pattern,
-                totalResults: matched.length,
-                truncated,
-                results,
-            }, estimator));
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return mcpText(fail(`Find file failed: ${msg}`));
-        }
-    });
+        });
+    }
     // ── mindmap_batch_read ────────────────────────────────────────
-    server.tool('mindmap_batch_read', 'Read multiple file regions in a single call. Eliminates per-call overhead when reading from several files. ' +
-        'Each file request specifies a path and optional line range. Returns all results at once.', {
-        files: z.array(z.object({
-            path: z.string().describe('Absolute or relative file path'),
-            startLine: z.number().int().min(1).default(1).describe('First line to read (1-indexed)'),
-            endLine: z.number().int().min(1).optional().describe('Last line to read (1-indexed). Omit to read 100 lines from startLine'),
-            label: z.string().optional().describe('Optional label/tag for this read (for AI to reference)'),
-        })).min(1).max(20).describe('Array of file read requests (max 20)'),
-        includeContext: z.boolean().default(true).describe('If true and graph is indexed, include containing symbol info'),
-    }, async ({ files: fileRequests, includeContext }) => {
-        const MAX_BATCH_FILES = 20;
-        const MAX_LINES_PER_READ = 300;
-        const DEFAULT_BATCH_WINDOW = 100;
-        const capped = fileRequests.slice(0, MAX_BATCH_FILES);
-        const results = [];
-        for (const req of capped) {
-            try {
-                // Resolve path: if not absolute, resolve against projectRoot
-                let resolved;
-                if (isAbsolute(req.path)) {
-                    resolved = resolve(req.path);
-                }
-                else {
-                    resolved = resolvePath(req.path, config.projectRoot, false);
-                }
-                if (!resolved) {
+    // CONSOLIDATED: mindmap_batch_read disabled to reduce schema payload
+    if (false) {
+        server.tool('mindmap_batch_read', 'Read multiple file regions in a single call. Eliminates per-call overhead when reading from several files. ' +
+            'Each file request specifies a path and optional line range. Returns all results at once.', {
+            files: z.array(z.object({
+                path: z.string().describe('Absolute or relative file path'),
+                startLine: z.number().int().min(1).default(1).describe('First line to read (1-indexed)'),
+                endLine: z.number().int().min(1).optional().describe('Last line to read (1-indexed). Omit to read 100 lines from startLine'),
+                label: z.string().optional().describe('Optional label/tag for this read (for AI to reference)'),
+            })).min(1).max(20).describe('Array of file read requests (max 20)'),
+            includeContext: z.boolean().default(true).describe('If true and graph is indexed, include containing symbol info'),
+        }, async ({ files: fileRequests, includeContext }) => {
+            const MAX_BATCH_FILES = 20;
+            const MAX_LINES_PER_READ = 300;
+            const DEFAULT_BATCH_WINDOW = 100;
+            const capped = fileRequests.slice(0, MAX_BATCH_FILES);
+            const results = [];
+            for (const req of capped) {
+                try {
+                    // Resolve path: if not absolute, resolve against projectRoot
+                    let resolved;
+                    if (isAbsolute(req.path)) {
+                        resolved = resolve(req.path);
+                    }
+                    else {
+                        resolved = resolvePath(req.path, config.projectRoot, false);
+                    }
+                    if (!resolved) {
+                        results.push({
+                            path: req.path,
+                            label: req.label,
+                            startLine: req.startLine,
+                            endLine: 0,
+                            totalLines: 0,
+                            lines: [],
+                            error: `Path "${req.path}" resolves outside the project root`,
+                        });
+                        continue;
+                    }
+                    if (!existsSync(resolved)) {
+                        results.push({
+                            path: req.path,
+                            label: req.label,
+                            startLine: req.startLine,
+                            endLine: 0,
+                            totalLines: 0,
+                            lines: [],
+                            error: `File not found: ${resolved}`,
+                        });
+                        continue;
+                    }
+                    const content = readFileSync(resolved, 'utf-8');
+                    const allLines = content.split('\n');
+                    const totalLines = allLines.length;
+                    // Normalise line range (1-indexed)
+                    const effectiveStart = Math.max(1, req.startLine);
+                    let effectiveEnd;
+                    if (req.endLine !== undefined) {
+                        effectiveEnd = Math.min(req.endLine, totalLines);
+                    }
+                    else {
+                        effectiveEnd = Math.min(effectiveStart + DEFAULT_BATCH_WINDOW - 1, totalLines);
+                    }
+                    // Cap at MAX_LINES_PER_READ
+                    if (effectiveEnd - effectiveStart + 1 > MAX_LINES_PER_READ) {
+                        effectiveEnd = effectiveStart + MAX_LINES_PER_READ - 1;
+                    }
+                    const lines = allLines.slice(effectiveStart - 1, effectiveEnd);
+                    // Graph context: find containing symbol
+                    let containingSymbol;
+                    if (includeContext && graph) {
+                        try {
+                            const nodes = graph.getFileStructure(resolved);
+                            if (nodes && nodes.length > 0) {
+                                let bestMatch = null;
+                                let bestRange = Infinity;
+                                for (const node of nodes) {
+                                    if (node.type !== 'file' &&
+                                        node.startLine <= effectiveStart &&
+                                        node.endLine >= effectiveStart) {
+                                        const range = node.endLine - node.startLine;
+                                        if (range < bestRange) {
+                                            bestRange = range;
+                                            bestMatch = node;
+                                        }
+                                    }
+                                }
+                                if (bestMatch) {
+                                    containingSymbol = {
+                                        name: bestMatch.name,
+                                        type: bestMatch.type,
+                                        signature: bestMatch.signature,
+                                        startLine: bestMatch.startLine,
+                                        endLine: bestMatch.endLine,
+                                    };
+                                }
+                            }
+                        }
+                        catch {
+                            // Graph not indexed yet or file not in graph — that's fine
+                        }
+                    }
                     results.push({
-                        path: req.path,
+                        path: resolved,
                         label: req.label,
-                        startLine: req.startLine,
-                        endLine: 0,
-                        totalLines: 0,
-                        lines: [],
-                        error: `Path "${req.path}" resolves outside the project root`,
+                        startLine: effectiveStart,
+                        endLine: effectiveEnd,
+                        totalLines,
+                        lines,
+                        ...(containingSymbol ? { containingSymbol } : {}),
                     });
-                    continue;
                 }
-                if (!existsSync(resolved)) {
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
                     results.push({
                         path: req.path,
                         label: req.label,
@@ -1038,85 +1123,12 @@ export function registerFilesystemTools(server, graph, config, estimator = defau
                         endLine: 0,
                         totalLines: 0,
                         lines: [],
-                        error: `File not found: ${resolved}`,
+                        error: `Failed to read: ${msg}`,
                     });
-                    continue;
-                }
-                const content = readFileSync(resolved, 'utf-8');
-                const allLines = content.split('\n');
-                const totalLines = allLines.length;
-                // Normalise line range (1-indexed)
-                const effectiveStart = Math.max(1, req.startLine);
-                let effectiveEnd;
-                if (req.endLine !== undefined) {
-                    effectiveEnd = Math.min(req.endLine, totalLines);
                 }
-                else {
-                    effectiveEnd = Math.min(effectiveStart + DEFAULT_BATCH_WINDOW - 1, totalLines);
-                }
-                // Cap at MAX_LINES_PER_READ
-                if (effectiveEnd - effectiveStart + 1 > MAX_LINES_PER_READ) {
-                    effectiveEnd = effectiveStart + MAX_LINES_PER_READ - 1;
-                }
-                const lines = allLines.slice(effectiveStart - 1, effectiveEnd);
-                // Graph context: find containing symbol
-                let containingSymbol;
-                if (includeContext && graph) {
-                    try {
-                        const nodes = graph.getFileStructure(resolved);
-                        if (nodes && nodes.length > 0) {
-                            let bestMatch = null;
-                            let bestRange = Infinity;
-                            for (const node of nodes) {
-                                if (node.type !== 'file' &&
-                                    node.startLine <= effectiveStart &&
-                                    node.endLine >= effectiveStart) {
-                                    const range = node.endLine - node.startLine;
-                                    if (range < bestRange) {
-                                        bestRange = range;
-                                        bestMatch = node;
-                                    }
-                                }
-                            }
-                            if (bestMatch) {
-                                containingSymbol = {
-                                    name: bestMatch.name,
-                                    type: bestMatch.type,
-                                    signature: bestMatch.signature,
-                                    startLine: bestMatch.startLine,
-                                    endLine: bestMatch.endLine,
-                                };
-                            }
-                        }
-                    }
-                    catch {
-                        // Graph not indexed yet or file not in graph — that's fine
-                    }
-                }
-                results.push({
-                    path: resolved,
-                    label: req.label,
-                    startLine: effectiveStart,
-                    endLine: effectiveEnd,
-                    totalLines,
-                    lines,
-                    ...(containingSymbol ? { containingSymbol } : {}),
-                });
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                results.push({
-                    path: req.path,
-                    label: req.label,
-                    startLine: req.startLine,
-                    endLine: 0,
-                    totalLines: 0,
-                    lines: [],
-                    error: `Failed to read: ${msg}`,
-                });
             }
-        }
-        return mcpText(ok({ totalFiles: results.length, results }, estimator));
-    });
+            return mcpText(ok({ totalFiles: results.length, results }, estimator));
+        });
+    }
 }
 //# sourceMappingURL=filesystem-tools.js.map