@rog0x/mcp-file-tools 1.0.0

package/dist/tools/duplicate-finder.js

@@ -0,0 +1,143 @@
+"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.duplicateFinder = duplicateFinder;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+function formatSize(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return (bytes / Math.pow(1024, i)).toFixed(2) + " " + units[i];
+}
+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__"].includes(entry.name))
+                continue;
+            collectFiles(fullPath, depth + 1, maxDepth, files);
+        }
+        else if (entry.isFile()) {
+            try {
+                const stat = fs.statSync(fullPath);
+                files.push({ path: fullPath, size: stat.size });
+            }
+            catch {
+                // Skip inaccessible files
+            }
+        }
+    }
+}
+function hashFile(filePath) {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash("md5").update(content).digest("hex");
+}
+async function duplicateFinder(options) {
+    const { dirPath, minSize = 1, maxDepth = 10 } = options;
+    const resolvedPath = path.resolve(dirPath);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Directory not found: ${resolvedPath}`);
+    }
+    const allFiles = [];
+    collectFiles(resolvedPath, 0, maxDepth, allFiles);
+    // Filter by minimum size
+    const filteredFiles = allFiles.filter((f) => f.size >= minSize);
+    // Group by size first (optimization: only hash files with matching sizes)
+    const sizeGroups = {};
+    for (const file of filteredFiles) {
+        if (!sizeGroups[file.size]) {
+            sizeGroups[file.size] = [];
+        }
+        sizeGroups[file.size].push(file);
+    }
+    // Hash only files that share a size
+    const hashGroups = {};
+    for (const [, group] of Object.entries(sizeGroups)) {
+        if (group.length < 2)
+            continue;
+        for (const file of group) {
+            try {
+                const hash = hashFile(file.path);
+                if (!hashGroups[hash]) {
+                    hashGroups[hash] = [];
+                }
+                hashGroups[hash].push(file);
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+    }
+    // Build result groups (only actual duplicates)
+    const groups = [];
+    let totalDuplicateFiles = 0;
+    let wastedSpaceBytes = 0;
+    for (const [hash, files] of Object.entries(hashGroups)) {
+        if (files.length < 2)
+            continue;
+        const sizeBytes = files[0].size;
+        groups.push({
+            hash,
+            size: formatSize(sizeBytes),
+            sizeBytes,
+            files: files.map((f) => f.path),
+        });
+        totalDuplicateFiles += files.length;
+        wastedSpaceBytes += sizeBytes * (files.length - 1);
+    }
+    // Sort by wasted space descending
+    groups.sort((a, b) => b.sizeBytes * (b.files.length - 1) - a.sizeBytes * (a.files.length - 1));
+    return {
+        directory: resolvedPath,
+        totalFilesScanned: filteredFiles.length,
+        duplicateGroups: groups.length,
+        totalDuplicateFiles,
+        wastedSpace: formatSize(wastedSpaceBytes),
+        wastedSpaceBytes,
+        groups: groups.slice(0, 50),
+    };
+}

package/dist/tools/file-search.d.ts

@@ -0,0 +1,36 @@
+interface FileSearchOptions {
+    dirPath: string;
+    namePattern?: string;
+    contentPattern?: string;
+    minSize?: number;
+    maxSize?: number;
+    modifiedAfter?: string;
+    modifiedBefore?: string;
+    maxResults?: number;
+}
+interface SearchMatch {
+    path: string;
+    size: string;
+    sizeBytes: number;
+    modified: string;
+    contentMatches?: {
+        line: number;
+        text: string;
+    }[];
+}
+interface FileSearchResult {
+    directory: string;
+    query: {
+        namePattern?: string;
+        contentPattern?: string;
+        minSize?: number;
+        maxSize?: number;
+        modifiedAfter?: string;
+        modifiedBefore?: string;
+    };
+    totalMatches: number;
+    matches: SearchMatch[];
+    truncated: boolean;
+}
+export declare function fileSearch(options: FileSearchOptions): Promise<FileSearchResult>;
+export {};

package/dist/tools/file-search.js

@@ -0,0 +1,146 @@
+"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.fileSearch = fileSearch;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+function formatSize(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return (bytes / Math.pow(1024, i)).toFixed(2) + " " + units[i];
+}
+async function fileSearch(options) {
+    const { dirPath, namePattern, contentPattern, minSize, maxSize, modifiedAfter, modifiedBefore, maxResults = 100, } = options;
+    const resolvedPath = path.resolve(dirPath);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Directory not found: ${resolvedPath}`);
+    }
+    // Find files by name pattern using glob
+    const globPattern = namePattern || "**/*";
+    const files = await (0, glob_1.glob)(globPattern, {
+        cwd: resolvedPath,
+        nodir: true,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/__pycache__/**"],
+        dot: false,
+    });
+    const matches = [];
+    const modAfterDate = modifiedAfter ? new Date(modifiedAfter) : null;
+    const modBeforeDate = modifiedBefore ? new Date(modifiedBefore) : null;
+    let contentRegex = null;
+    if (contentPattern) {
+        try {
+            contentRegex = new RegExp(contentPattern, "gi");
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`Invalid content regex: ${msg}`);
+        }
+    }
+    for (const filePath of files) {
+        if (matches.length >= maxResults)
+            break;
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        }
+        catch {
+            continue;
+        }
+        // Size filters
+        if (minSize !== undefined && stat.size < minSize)
+            continue;
+        if (maxSize !== undefined && stat.size > maxSize)
+            continue;
+        // Date filters
+        if (modAfterDate && stat.mtime < modAfterDate)
+            continue;
+        if (modBeforeDate && stat.mtime > modBeforeDate)
+            continue;
+        // Content search
+        let contentMatches;
+        if (contentRegex) {
+            // Skip binary files and very large files
+            if (stat.size > 10 * 1024 * 1024)
+                continue;
+            let content;
+            try {
+                content = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            // Quick binary check
+            if (content.includes("\0"))
+                continue;
+            const lines = content.split(/\r?\n/);
+            contentMatches = [];
+            for (let i = 0; i < lines.length; i++) {
+                contentRegex.lastIndex = 0;
+                if (contentRegex.test(lines[i])) {
+                    contentMatches.push({ line: i + 1, text: lines[i].trim().substring(0, 200) });
+                    if (contentMatches.length >= 20)
+                        break;
+                }
+            }
+            if (contentMatches.length === 0)
+                continue;
+        }
+        matches.push({
+            path: filePath,
+            size: formatSize(stat.size),
+            sizeBytes: stat.size,
+            modified: stat.mtime.toISOString(),
+            ...(contentMatches ? { contentMatches } : {}),
+        });
+    }
+    return {
+        directory: resolvedPath,
+        query: {
+            ...(namePattern ? { namePattern } : {}),
+            ...(contentPattern ? { contentPattern } : {}),
+            ...(minSize !== undefined ? { minSize } : {}),
+            ...(maxSize !== undefined ? { maxSize } : {}),
+            ...(modifiedAfter ? { modifiedAfter } : {}),
+            ...(modifiedBefore ? { modifiedBefore } : {}),
+        },
+        totalMatches: matches.length,
+        matches,
+        truncated: matches.length >= maxResults,
+    };
+}

package/dist/tools/file-stats.d.ts

@@ -0,0 +1,25 @@
+interface FileStatsOptions {
+    dirPath: string;
+    maxDepth?: number;
+}
+interface FileInfo {
+    path: string;
+    size: number;
+    modified: string;
+}
+interface FileStatsResult {
+    directory: string;
+    totalFiles: number;
+    totalSize: string;
+    totalSizeBytes: number;
+    extensionCounts: Record<string, {
+        count: number;
+        totalSize: string;
+        totalSizeBytes: number;
+    }>;
+    largestFiles: FileInfo[];
+    newestFiles: FileInfo[];
+    oldestFiles: FileInfo[];
+}
+export declare function fileStats(options: FileStatsOptions): Promise<FileStatsResult>;
+export {};

package/dist/tools/file-stats.js

@@ -0,0 +1,128 @@
+"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.fileStats = fileStats;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function formatSize(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return (bytes / Math.pow(1024, i)).toFixed(2) + " " + units[i];
+}
+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__"].includes(entry.name))
+                continue;
+            collectFiles(fullPath, depth + 1, maxDepth, files);
+        }
+        else if (entry.isFile()) {
+            try {
+                const stat = fs.statSync(fullPath);
+                files.push({
+                    path: fullPath,
+                    size: stat.size,
+                    modified: stat.mtime.toISOString(),
+                });
+            }
+            catch {
+                // Skip inaccessible files
+            }
+        }
+    }
+}
+async function fileStats(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 totalSizeBytes = files.reduce((sum, f) => sum + f.size, 0);
+    // Count by extension
+    const extMap = {};
+    for (const file of files) {
+        const ext = path.extname(file.path).toLowerCase() || "(no extension)";
+        if (!extMap[ext]) {
+            extMap[ext] = { count: 0, totalSizeBytes: 0 };
+        }
+        extMap[ext].count++;
+        extMap[ext].totalSizeBytes += file.size;
+    }
+    const extensionCounts = {};
+    const sortedExts = Object.entries(extMap).sort((a, b) => b[1].count - a[1].count);
+    for (const [ext, data] of sortedExts) {
+        extensionCounts[ext] = {
+            count: data.count,
+            totalSize: formatSize(data.totalSizeBytes),
+            totalSizeBytes: data.totalSizeBytes,
+        };
+    }
+    // Largest files (top 10)
+    const largestFiles = [...files]
+        .sort((a, b) => b.size - a.size)
+        .slice(0, 10);
+    // Newest files (top 10)
+    const newestFiles = [...files]
+        .sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime())
+        .slice(0, 10);
+    // Oldest files (top 10)
+    const oldestFiles = [...files]
+        .sort((a, b) => new Date(a.modified).getTime() - new Date(b.modified).getTime())
+        .slice(0, 10);
+    return {
+        directory: resolvedPath,
+        totalFiles: files.length,
+        totalSize: formatSize(totalSizeBytes),
+        totalSizeBytes,
+        extensionCounts,
+        largestFiles,
+        newestFiles,
+        oldestFiles,
+    };
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@rog0x/mcp-file-tools",
+  "version": "1.0.0",
+  "description": "MCP server providing file and directory analysis tools for AI agents",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-file-tools": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "ai",
+    "file-tools",
+    "directory-tree",
+    "code-counter",
+    "duplicate-finder"
+  ],
+  "author": "rog0x",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rog0x/mcp-file-tools"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "glob": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  }
+}