@rog0x/mcp-file-tools 1.0.0

package/README.md

@@ -0,0 +1,115 @@
+# @rog0x/mcp-file-tools
+
+MCP server providing file and directory analysis tools for AI agents. Gives Claude (and other MCP-compatible AI) the ability to explore, analyze, and search file systems.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `dir_tree` | Generate a visual directory tree structure with configurable depth and ignore patterns |
+| `file_stats` | Analyze a directory: total files, size breakdown by extension, largest/newest/oldest files |
+| `duplicate_finder` | Find duplicate files by size + MD5 hash, report wasted space |
+| `code_counter` | Count lines of code by language: code, comments, and blank lines (like cloc/scc) |
+| `file_search` | Search files by name glob, content regex, size range, and date range |
+
+## Installation
+
+```bash
+git clone https://github.com/rog0x/mcp-file-tools.git
+cd mcp-file-tools
+npm install
+npm run build
+```
+
+## Configuration
+
+### Claude Code
+
+```bash
+claude mcp add mcp-file-tools node /absolute/path/to/mcp-file-tools/dist/index.js
+```
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "mcp-file-tools": {
+      "command": "node",
+      "args": ["/absolute/path/to/mcp-file-tools/dist/index.js"]
+    }
+  }
+}
+```
+
+## Tool Details
+
+### dir_tree
+
+Generate a visual directory tree like the `tree` command.
+
+```
+Parameters:
+  dir_path (required)     - Absolute path to the directory
+  max_depth (optional)    - Max depth to traverse (default: 5, 0 = unlimited)
+  ignore_patterns (optional) - Patterns to ignore (default: node_modules, .git, dist, etc.)
+```
+
+### file_stats
+
+Get a comprehensive analysis of a directory's contents.
+
+```
+Parameters:
+  dir_path (required)     - Absolute path to the directory
+  max_depth (optional)    - Max depth to traverse (default: 10)
+```
+
+Returns: total files, total size, file counts by extension, top 10 largest files, top 10 newest/oldest files.
+
+### duplicate_finder
+
+Find duplicate files using size pre-filtering and MD5 hashing.
+
+```
+Parameters:
+  dir_path (required)     - Absolute path to the directory
+  min_size (optional)     - Minimum file size in bytes (default: 1)
+  max_depth (optional)    - Max depth to traverse (default: 10)
+```
+
+Returns: duplicate groups with file paths, sizes, and total wasted space.
+
+### code_counter
+
+Count lines of code across 20+ languages with comment detection.
+
+```
+Parameters:
+  dir_path (required)     - Absolute path to the directory
+  max_depth (optional)    - Max depth to traverse (default: 10)
+```
+
+Supported languages: TypeScript, JavaScript, Python, Java, C/C++, C#, Go, Rust, Ruby, PHP, Swift, Kotlin, HTML, CSS, JSON, YAML, Markdown, Shell, SQL, Lua.
+
+### file_search
+
+Search for files using multiple criteria simultaneously.
+
+```
+Parameters:
+  dir_path (required)        - Absolute path to the directory
+  name_pattern (optional)    - Glob pattern (e.g. "**/*.ts")
+  content_pattern (optional) - Regex to search file contents
+  min_size (optional)        - Minimum file size in bytes
+  max_size (optional)        - Maximum file size in bytes
+  modified_after (optional)  - ISO date string
+  modified_before (optional) - ISO date string
+  max_results (optional)     - Max results (default: 100)
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const dir_tree_js_1 = require("./tools/dir-tree.js");
+const file_stats_js_1 = require("./tools/file-stats.js");
+const duplicate_finder_js_1 = require("./tools/duplicate-finder.js");
+const code_counter_js_1 = require("./tools/code-counter.js");
+const file_search_js_1 = require("./tools/file-search.js");
+const server = new index_js_1.Server({
+    name: "mcp-file-tools",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "dir_tree",
+            description: "Generate a visual directory tree structure (like the `tree` command). Shows files and folders with configurable depth and ignore patterns.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dir_path: { type: "string", description: "Absolute path to the directory" },
+                    max_depth: {
+                        type: "number",
+                        description: "Maximum depth to traverse (default: 5, 0 = unlimited)",
+                    },
+                    ignore_patterns: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Patterns to ignore (default: node_modules, .git, dist, __pycache__, .next, .cache, coverage)",
+                    },
+                },
+                required: ["dir_path"],
+            },
+        },
+        {
+            name: "file_stats",
+            description: "Analyze a directory: total files, total size, file count by extension, largest files, newest/oldest files.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dir_path: { type: "string", description: "Absolute path to the directory" },
+                    max_depth: {
+                        type: "number",
+                        description: "Maximum depth to traverse (default: 10, 0 = unlimited)",
+                    },
+                },
+                required: ["dir_path"],
+            },
+        },
+        {
+            name: "duplicate_finder",
+            description: "Find duplicate files by comparing size and MD5 hash. Returns groups of duplicates with paths and wasted space.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dir_path: { type: "string", description: "Absolute path to the directory" },
+                    min_size: {
+                        type: "number",
+                        description: "Minimum file size in bytes to consider (default: 1)",
+                    },
+                    max_depth: {
+                        type: "number",
+                        description: "Maximum depth to traverse (default: 10)",
+                    },
+                },
+                required: ["dir_path"],
+            },
+        },
+        {
+            name: "code_counter",
+            description: "Count lines of code by programming language: total lines, code lines, comment lines, blank lines (like cloc/scc).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dir_path: { type: "string", description: "Absolute path to the directory" },
+                    max_depth: {
+                        type: "number",
+                        description: "Maximum depth to traverse (default: 10)",
+                    },
+                },
+                required: ["dir_path"],
+            },
+        },
+        {
+            name: "file_search",
+            description: "Search for files by name pattern (glob), content (regex), size range, and/or date range.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dir_path: { type: "string", description: "Absolute path to the directory to search" },
+                    name_pattern: {
+                        type: "string",
+                        description: 'Glob pattern for file names (e.g. "**/*.ts", "*.json")',
+                    },
+                    content_pattern: {
+                        type: "string",
+                        description: "Regex pattern to search within file contents",
+                    },
+                    min_size: {
+                        type: "number",
+                        description: "Minimum file size in bytes",
+                    },
+                    max_size: {
+                        type: "number",
+                        description: "Maximum file size in bytes",
+                    },
+                    modified_after: {
+                        type: "string",
+                        description: "ISO date string - only files modified after this date",
+                    },
+                    modified_before: {
+                        type: "string",
+                        description: "ISO date string - only files modified before this date",
+                    },
+                    max_results: {
+                        type: "number",
+                        description: "Maximum number of results to return (default: 100)",
+                    },
+                },
+                required: ["dir_path"],
+            },
+        },
+    ],
+}));
+// Handle tool calls
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "dir_tree": {
+                const result = await (0, dir_tree_js_1.dirTree)({
+                    dirPath: args?.dir_path,
+                    maxDepth: args?.max_depth,
+                    ignorePatterns: args?.ignore_patterns,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "file_stats": {
+                const result = await (0, file_stats_js_1.fileStats)({
+                    dirPath: args?.dir_path,
+                    maxDepth: args?.max_depth,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "duplicate_finder": {
+                const result = await (0, duplicate_finder_js_1.duplicateFinder)({
+                    dirPath: args?.dir_path,
+                    minSize: args?.min_size,
+                    maxDepth: args?.max_depth,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "code_counter": {
+                const result = await (0, code_counter_js_1.codeCounter)({
+                    dirPath: args?.dir_path,
+                    maxDepth: args?.max_depth,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "file_search": {
+                const result = await (0, file_search_js_1.fileSearch)({
+                    dirPath: args?.dir_path,
+                    namePattern: args?.name_pattern,
+                    contentPattern: args?.content_pattern,
+                    minSize: args?.min_size,
+                    maxSize: args?.max_size,
+                    modifiedAfter: args?.modified_after,
+                    modifiedBefore: args?.modified_before,
+                    maxResults: args?.max_results,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP File Tools server running on stdio");
+}
+main().catch(console.error);

package/dist/tools/code-counter.d.ts

@@ -0,0 +1,22 @@
+interface CodeCounterOptions {
+    dirPath: string;
+    maxDepth?: number;
+}
+interface LanguageStats {
+    files: number;
+    totalLines: number;
+    codeLines: number;
+    commentLines: number;
+    blankLines: number;
+}
+interface CodeCounterResult {
+    directory: string;
+    totalFiles: number;
+    totalLines: number;
+    totalCodeLines: number;
+    totalCommentLines: number;
+    totalBlankLines: number;
+    languages: Record<string, LanguageStats>;
+}
+export declare function codeCounter(options: CodeCounterOptions): Promise<CodeCounterResult>;
+export {};

package/dist/tools/code-counter.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeCounter = codeCounter;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const LANGUAGES = [
+    { name: "TypeScript", extensions: [".ts", ".tsx"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "JavaScript", extensions: [".js", ".jsx", ".mjs", ".cjs"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "Python", extensions: [".py", ".pyw"], singleLineComment: ["#"], blockCommentStart: '"""', blockCommentEnd: '"""' },
+    { name: "Java", extensions: [".java"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "C/C++", extensions: [".c", ".cpp", ".cc", ".h", ".hpp"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "C#", extensions: [".cs"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "Go", extensions: [".go"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "Rust", extensions: [".rs"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "Ruby", extensions: [".rb"], singleLineComment: ["#"], blockCommentStart: "=begin", blockCommentEnd: "=end" },
+    { name: "PHP", extensions: [".php"], singleLineComment: ["//", "#"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "Swift", extensions: [".swift"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "Kotlin", extensions: [".kt", ".kts"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "HTML", extensions: [".html", ".htm"], singleLineComment: [], blockCommentStart: "<!--", blockCommentEnd: "-->" },
+    { name: "CSS", extensions: [".css", ".scss", ".sass", ".less"], singleLineComment: ["//"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "JSON", extensions: [".json"], singleLineComment: [], },
+    { name: "YAML", extensions: [".yml", ".yaml"], singleLineComment: ["#"] },
+    { name: "Markdown", extensions: [".md", ".mdx"], singleLineComment: [] },
+    { name: "Shell", extensions: [".sh", ".bash", ".zsh"], singleLineComment: ["#"] },
+    { name: "SQL", extensions: [".sql"], singleLineComment: ["--"], blockCommentStart: "/*", blockCommentEnd: "*/" },
+    { name: "Lua", extensions: [".lua"], singleLineComment: ["--"], blockCommentStart: "--[[", blockCommentEnd: "]]" },
+];
+const EXT_TO_LANG = {};
+for (const lang of LANGUAGES) {
+    for (const ext of lang.extensions) {
+        EXT_TO_LANG[ext] = lang;
+    }
+}
+function countLines(filePath, lang) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return { totalLines: 0, codeLines: 0, commentLines: 0, blankLines: 0 };
+    }
+    const lines = content.split(/\r?\n/);
+    let blankLines = 0;
+    let commentLines = 0;
+    let codeLines = 0;
+    let inBlockComment = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === "") {
+            blankLines++;
+            continue;
+        }
+        if (inBlockComment) {
+            commentLines++;
+            if (lang.blockCommentEnd && trimmed.includes(lang.blockCommentEnd)) {
+                inBlockComment = false;
+            }
+            continue;
+        }
+        if (lang.blockCommentStart && trimmed.startsWith(lang.blockCommentStart)) {
+            commentLines++;
+            if (!lang.blockCommentEnd || !trimmed.includes(lang.blockCommentEnd, lang.blockCommentStart.length)) {
+                inBlockComment = true;
+            }
+            continue;
+        }
+        const isSingleComment = lang.singleLineComment.some((prefix) => trimmed.startsWith(prefix));
+        if (isSingleComment) {
+            commentLines++;
+        }
+        else {
+            codeLines++;
+        }
+    }
+    return {
+        totalLines: lines.length,
+        codeLines,
+        commentLines,
+        blankLines,
+    };
+}
+function collectFiles(dirPath, depth, maxDepth, files) {
+    if (maxDepth > 0 && depth >= maxDepth)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            if (["node_modules", ".git", "dist", "__pycache__", ".next", "coverage", "build"].includes(entry.name))
+                continue;
+            collectFiles(fullPath, depth + 1, maxDepth, files);
+        }
+        else if (entry.isFile()) {
+            const ext = path.extname(entry.name).toLowerCase();
+            if (EXT_TO_LANG[ext]) {
+                files.push(fullPath);
+            }
+        }
+    }
+}
+async function codeCounter(options) {
+    const { dirPath, maxDepth = 10 } = options;
+    const resolvedPath = path.resolve(dirPath);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Directory not found: ${resolvedPath}`);
+    }
+    const files = [];
+    collectFiles(resolvedPath, 0, maxDepth, files);
+    const langStats = {};
+    let totalLines = 0;
+    let totalCodeLines = 0;
+    let totalCommentLines = 0;
+    let totalBlankLines = 0;
+    for (const filePath of files) {
+        const ext = path.extname(filePath).toLowerCase();
+        const lang = EXT_TO_LANG[ext];
+        if (!lang)
+            continue;
+        const counts = countLines(filePath, lang);
+        if (!langStats[lang.name]) {
+            langStats[lang.name] = { files: 0, totalLines: 0, codeLines: 0, commentLines: 0, blankLines: 0 };
+        }
+        langStats[lang.name].files++;
+        langStats[lang.name].totalLines += counts.totalLines;
+        langStats[lang.name].codeLines += counts.codeLines;
+        langStats[lang.name].commentLines += counts.commentLines;
+        langStats[lang.name].blankLines += counts.blankLines;
+        totalLines += counts.totalLines;
+        totalCodeLines += counts.codeLines;
+        totalCommentLines += counts.commentLines;
+        totalBlankLines += counts.blankLines;
+    }
+    // Sort languages by code lines descending
+    const sortedLangs = {};
+    const sorted = Object.entries(langStats).sort((a, b) => b[1].codeLines - a[1].codeLines);
+    for (const [name, stats] of sorted) {
+        sortedLangs[name] = stats;
+    }
+    return {
+        directory: resolvedPath,
+        totalFiles: files.length,
+        totalLines,
+        totalCodeLines,
+        totalCommentLines,
+        totalBlankLines,
+        languages: sortedLangs,
+    };
+}

package/dist/tools/dir-tree.d.ts

@@ -0,0 +1,12 @@
+interface DirTreeOptions {
+    dirPath: string;
+    maxDepth?: number;
+    ignorePatterns?: string[];
+}
+interface TreeResult {
+    tree: string;
+    totalDirs: number;
+    totalFiles: number;
+}
+export declare function dirTree(options: DirTreeOptions): Promise<TreeResult>;
+export {};

package/dist/tools/dir-tree.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dirTree = dirTree;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const DEFAULT_IGNORE = ["node_modules", ".git", "dist", "__pycache__", ".next", ".cache", "coverage"];
+function shouldIgnore(name, ignorePatterns) {
+    return ignorePatterns.some((pattern) => {
+        if (pattern.includes("*")) {
+            const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+            return regex.test(name);
+        }
+        return name === pattern;
+    });
+}
+function buildTree(dirPath, prefix, depth, maxDepth, ignorePatterns, stats) {
+    if (maxDepth > 0 && depth >= maxDepth) {
+        return [];
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [`${prefix}[permission denied]`];
+    }
+    entries = entries.filter((e) => !shouldIgnore(e.name, ignorePatterns));
+    entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    const lines = [];
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const isLast = i === entries.length - 1;
+        const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+        const childPrefix = isLast ? "    " : "\u2502   ";
+        if (entry.isDirectory()) {
+            stats.dirs++;
+            lines.push(`${prefix}${connector}${entry.name}/`);
+            const childLines = buildTree(path.join(dirPath, entry.name), prefix + childPrefix, depth + 1, maxDepth, ignorePatterns, stats);
+            lines.push(...childLines);
+        }
+        else {
+            stats.files++;
+            lines.push(`${prefix}${connector}${entry.name}`);
+        }
+    }
+    return lines;
+}
+async function dirTree(options) {
+    const { dirPath, maxDepth = 5, ignorePatterns = DEFAULT_IGNORE } = options;
+    const resolvedPath = path.resolve(dirPath);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Directory not found: ${resolvedPath}`);
+    }
+    const stat = fs.statSync(resolvedPath);
+    if (!stat.isDirectory()) {
+        throw new Error(`Not a directory: ${resolvedPath}`);
+    }
+    const stats = { dirs: 0, files: 0 };
+    const rootName = path.basename(resolvedPath);
+    const lines = [`${rootName}/`];
+    const childLines = buildTree(resolvedPath, "", 0, maxDepth, ignorePatterns, stats);
+    lines.push(...childLines);
+    return {
+        tree: lines.join("\n"),
+        totalDirs: stats.dirs,
+        totalFiles: stats.files,
+    };
+}

package/dist/tools/duplicate-finder.d.ts

@@ -0,0 +1,22 @@
+interface DuplicateFinderOptions {
+    dirPath: string;
+    minSize?: number;
+    maxDepth?: number;
+}
+interface DuplicateGroup {
+    hash: string;
+    size: string;
+    sizeBytes: number;
+    files: string[];
+}
+interface DuplicateResult {
+    directory: string;
+    totalFilesScanned: number;
+    duplicateGroups: number;
+    totalDuplicateFiles: number;
+    wastedSpace: string;
+    wastedSpaceBytes: number;
+    groups: DuplicateGroup[];
+}
+export declare function duplicateFinder(options: DuplicateFinderOptions): Promise<DuplicateResult>;
+export {};