@rog0x/mcp-file-tools 1.0.0

package/src/tools/file-search.ts

@@ -0,0 +1,157 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+
+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;
+}
+
+function formatSize(bytes: number): string {
+  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];
+}
+
+export async function fileSearch(options: FileSearchOptions): Promise<FileSearchResult> {
+  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 glob(globPattern, {
+    cwd: resolvedPath,
+    nodir: true,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/__pycache__/**"],
+    dot: false,
+  });
+
+  const matches: SearchMatch[] = [];
+  const modAfterDate = modifiedAfter ? new Date(modifiedAfter) : null;
+  const modBeforeDate = modifiedBefore ? new Date(modifiedBefore) : null;
+  let contentRegex: RegExp | null = null;
+  if (contentPattern) {
+    try {
+      contentRegex = new RegExp(contentPattern, "gi");
+    } catch (e: unknown) {
+      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: fs.Stats;
+    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: { line: number; text: string }[] | undefined;
+    if (contentRegex) {
+      // Skip binary files and very large files
+      if (stat.size > 10 * 1024 * 1024) continue;
+
+      let content: string;
+      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/src/tools/file-stats.ts

@@ -0,0 +1,128 @@
+import * as fs from "fs";
+import * as path from "path";
+
+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[];
+}
+
+function formatSize(bytes: number): string {
+  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: string,
+  depth: number,
+  maxDepth: number,
+  files: FileInfo[]
+): void {
+  if (maxDepth > 0 && depth >= maxDepth) return;
+
+  let entries: fs.Dirent[];
+  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
+      }
+    }
+  }
+}
+
+export async function fileStats(options: FileStatsOptions): Promise<FileStatsResult> {
+  const { dirPath, maxDepth = 10 } = options;
+  const resolvedPath = path.resolve(dirPath);
+
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Directory not found: ${resolvedPath}`);
+  }
+
+  const files: FileInfo[] = [];
+  collectFiles(resolvedPath, 0, maxDepth, files);
+
+  const totalSizeBytes = files.reduce((sum, f) => sum + f.size, 0);
+
+  // Count by extension
+  const extMap: Record<string, { count: number; totalSizeBytes: number }> = {};
+  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: Record<string, { count: number; totalSize: string; totalSizeBytes: number }> = {};
+  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/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"]
+}