@j0hanz/filesystem-mcp 1.8.0 → 1.9.0

package/dist/cli.js

@@ -2,8 +2,8 @@ import * as fs from 'node:fs/promises';
 import { getSystemErrorMessage, getSystemErrorName } from 'node:util';
 import { Command, CommanderError, InvalidArgumentError } from 'commander';
 import { processInParallel } from './lib/fs-helpers.js';
-import { getReservedDeviceNameForPath, isWindowsDriveRelativePath, normalizePath, } from './lib/path-validation.js';
-import { isRecord } from './lib/type-guards.js';
+import { getReservedDeviceNameForPath, isWindowsDriveRelativePath, normalizePath, } from './lib/paths.js';
+import { isRecord } from './lib/utils.js';
 import { pkgInfo } from './pkg-info.js';
 const { version: SERVER_VERSION } = pkgInfo;
 const IS_WINDOWS = process.platform === 'win32';

package/dist/completions.js

@@ -1,9 +1,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { CompleteRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { toPosixPath } from './lib/path-format.js';
-import { getAllowedDirectories, isPathWithinDirectories, normalizePath, } from './lib/path-validation.js';
-import { isRecord } from './lib/type-guards.js';
+import { getAllowedDirectories, isPathWithinDirectories, normalizePath, toPosixPath, } from './lib/paths.js';
+import { isRecord } from './lib/utils.js';
 const MAX_COMPLETION_ITEMS = 100;
 const COMPLETION_RATE_LIMIT_MS = 100;
 // WeakMap keyed by McpServer instance so that each HTTP session gets isolated

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import process from 'node:process';
-import { CliExitError, parseArgs } from './cli.js';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from './lib/constants.js';
 import { formatUnknownErrorMessage } from './lib/errors.js';
 import { createTimedAbortSignal } from './lib/fs-helpers.js';
-import { setAllowedDirectoriesResolved } from './lib/path-validation.js';
+import { setAllowedDirectoriesResolved } from './lib/paths.js';
+import { CliExitError, parseArgs } from './cli.js';
 import { createServer, startHttpServer, startServer } from './server.js';
 const SHUTDOWN_TIMEOUT_MS = 5000;
 let activeServer;

package/dist/lib/file-operations/{common.d.ts → core.d.ts}

@@ -1,3 +1,4 @@
+import { type Ignore } from 'ignore';
 export declare function needsStatsForSort(sortBy: string): boolean;
 export declare function withOptionalStoppedReason<T extends object, R extends string>(summary: T, stoppedReason: R | undefined): T | (T & {
     stoppedReason: R;
@@ -44,3 +45,8 @@ export interface EntryAccessDependencies {
     }>;
 }
 export declare function isEntryAccessibleByType(entryPath: string, entryType: EntryType, rootDirectories: readonly string[], signal: AbortSignal, deps: EntryAccessDependencies): Promise<boolean>;
+export declare function loadRootGitignore(root: string, signal?: AbortSignal): Promise<Ignore | null>;
+export declare function isIgnoredByGitignore(matcher: Ignore, root: string, absolutePath: string, options?: {
+    isDirectory?: boolean;
+    relativePath?: string;
+}): boolean;

package/dist/lib/file-operations/{common.js → core.js}

@@ -1,3 +1,8 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import ignore, {} from 'ignore';
+import { isNodeError } from '../errors.js';
+import { toPosixPath } from '../paths.js';
 export function needsStatsForSort(sortBy) {
     return sortBy === 'size' || sortBy === 'modified';
 }
@@ -94,3 +99,43 @@ export async function isEntryAccessibleByType(entryPath, entryType, rootDirector
         return false;
     }
 }
+function parseGitignoreLines(contents) {
+    const lines = [];
+    for (const line of contents.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+            lines.push(trimmed);
+        }
+    }
+    return lines;
+}
+export async function loadRootGitignore(root, signal) {
+    const gitignorePath = path.join(root, '.gitignore');
+    let contents;
+    try {
+        contents = await fs.readFile(gitignorePath, {
+            encoding: 'utf-8',
+            signal,
+        });
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+    const matcher = ignore();
+    matcher.add(parseGitignoreLines(contents));
+    return matcher;
+}
+export function isIgnoredByGitignore(matcher, root, absolutePath, options = {}) {
+    let relative = options.relativePath;
+    relative ??= path.relative(root, absolutePath);
+    if (relative.length === 0)
+        return false;
+    const normalized = toPosixPath(relative);
+    if (options.isDirectory) {
+        return matcher.ignores(normalized.endsWith('/') ? normalized : `${normalized}/`);
+    }
+    return matcher.ignores(normalized);
+}

package/dist/lib/file-operations/metadata.d.ts

@@ -0,0 +1,73 @@
+import type { FileInfo, GetMultipleFileInfoResult, ListDirectoryResult } from '../../config.js';
+import type { EntryType } from './core.js';
+interface FileInfoOptions {
+    includeMimeType?: boolean | undefined;
+    signal?: AbortSignal | undefined;
+    onProgress?: () => void;
+}
+export declare function getFileInfo(filePath: string, options?: FileInfoOptions): Promise<FileInfo>;
+type GetMultipleFileInfoOptions = FileInfoOptions;
+export declare function getMultipleFileInfo(paths: readonly string[], options?: GetMultipleFileInfoOptions): Promise<GetMultipleFileInfoResult>;
+interface ListDirectoryOptions {
+    includeHidden?: boolean;
+    excludePatterns?: readonly string[];
+    maxDepth?: number;
+    maxEntries?: number;
+    sortBy?: 'name' | 'size' | 'modified' | 'type';
+    includeSymlinkTargets?: boolean;
+    pattern?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export declare function listDirectory(dirPath: string, options?: ListDirectoryOptions): Promise<ListDirectoryResult>;
+interface TreeEntry {
+    name: string;
+    type: EntryType;
+    relativePath: string;
+    children?: TreeEntry[];
+}
+interface TreeOptions {
+    maxDepth?: number;
+    maxEntries?: number;
+    includeHidden?: boolean;
+    includeIgnored?: boolean;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onProgress?: (progress: {
+        total?: number;
+        current: number;
+    }) => void;
+}
+interface TreeResult {
+    root: string;
+    tree: TreeEntry;
+    truncated: boolean;
+    totalEntries: number;
+}
+export declare function formatTreeAscii(tree: TreeEntry): string;
+export declare function treeDirectory(dirPath: string, options?: TreeOptions): Promise<TreeResult>;
+interface ReadMultipleResult {
+    path: string;
+    content?: string;
+    truncated?: boolean;
+    totalLines?: number;
+    readMode?: 'full' | 'head' | 'range';
+    head?: number;
+    startLine?: number;
+    endLine?: number;
+    linesRead?: number;
+    hasMoreLines?: boolean;
+    error?: string;
+}
+interface ReadMultipleOptions {
+    encoding?: BufferEncoding;
+    maxSize?: number;
+    maxTotalSize?: number;
+    head?: number;
+    startLine?: number;
+    endLine?: number;
+    signal?: AbortSignal;
+    onReadComplete?: () => void;
+}
+export declare function readMultipleFiles(filePaths: readonly string[], options?: ReadMultipleOptions): Promise<ReadMultipleResult[]>;
+export {};