@j0hanz/fs-context-mcp 2.0.0 → 2.0.1

package/dist/schemas/outputs/read.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ErrorSchema } from '../error-schema.js';
+import { OperationSummarySchema } from '../output-helpers.js';
 export const ReadFileOutputSchema = z.object({
     ok: z.boolean(),
     path: z.string().optional(),
@@ -18,13 +19,7 @@ export const ReadMultipleFilesOutputSchema = z.object({
         error: z.string().optional(),
     }))
         .optional(),
-    summary: z
-        .object({
-        total: z.number(),
-        succeeded: z.number(),
-        failed: z.number(),
-    })
-        .optional(),
+    summary: OperationSummarySchema.optional(),
     error: ErrorSchema.optional(),
 });
 //# sourceMappingURL=read.js.map

package/dist/schemas/outputs/read.js.map

@@ -1 +1 @@
-{"version":3,"file":"read.js","sourceRoot":"","sources":["../../../src/schemas/outputs/read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE;IACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACjC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,KAAK,EAAE,WAAW,CAAC,QAAQ,EAAE;CAC9B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAAC;IACpD,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE;IACf,OAAO,EAAE,CAAC;SACP,KAAK,CACJ,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC9B,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QACjC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC7B,CAAC,CACH;SACA,QAAQ,EAAE;IACb,OAAO,EAAE,CAAC;SACP,MAAM,CAAC;QACN,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;QACjB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;QACrB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;KACnB,CAAC;SACD,QAAQ,EAAE;IACb,KAAK,EAAE,WAAW,CAAC,QAAQ,EAAE;CAC9B,CAAC,CAAC"}
+{"version":3,"file":"read.js","sourceRoot":"","sources":["../../../src/schemas/outputs/read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE;IACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACjC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,KAAK,EAAE,WAAW,CAAC,QAAQ,EAAE;CAC9B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAAC;IACpD,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE;IACf,OAAO,EAAE,CAAC;SACP,KAAK,CACJ,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC9B,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QACjC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC7B,CAAC,CACH;SACA,QAAQ,EAAE;IACb,OAAO,EAAE,sBAAsB,CAAC,QAAQ,EAAE;IAC1C,KAAK,EAAE,WAAW,CAAC,QAAQ,EAAE;CAC9B,CAAC,CAAC"}

package/dist/schemas.d.ts

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+export declare const FileTypeSchema: z.ZodEnum<{
+    file: "file";
+    directory: "directory";
+    symlink: "symlink";
+    other: "other";
+}>;
+export declare const ErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const HeadLinesSchema: z.ZodOptional<z.ZodInt>;
+export declare const FileInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    type: z.ZodEnum<{
+        file: "file";
+        directory: "directory";
+        symlink: "symlink";
+        other: "other";
+    }>;
+    size: z.ZodNumber;
+    created: z.ZodOptional<z.ZodString>;
+    modified: z.ZodString;
+    accessed: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodString;
+    isHidden: z.ZodOptional<z.ZodBoolean>;
+    mimeType: z.ZodOptional<z.ZodString>;
+    symlinkTarget: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const OperationSummarySchema: z.ZodObject<{
+    total: z.ZodNumber;
+    succeeded: z.ZodNumber;
+    failed: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ListDirectoryInputSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    excludePatterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    pattern: z.ZodOptional<z.ZodString>;
+    maxDepth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxEntries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sortBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        size: "size";
+        modified: "modified";
+        type: "type";
+    }>>>;
+    includeSymlinkTargets: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strict>;
+export declare const ListAllowedDirectoriesInputSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const SearchFilesInputSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    pattern: z.ZodString;
+    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strict>;
+export declare const SearchContentInputSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    pattern: z.ZodString;
+    filePattern: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxFileSize: z.ZodOptional<z.ZodNumber>;
+    maxFilesScanned: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    skipBinary: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    contextLines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    wholeWord: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    isLiteral: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    baseNameMatch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    caseSensitiveFileMatch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeIgnored: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strict>;
+export declare const ReadFileInputSchema: z.ZodObject<{
+    path: z.ZodString;
+    head: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export declare const ReadMultipleFilesInputSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+    head: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export declare const GetFileInfoInputSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
+export declare const GetMultipleFileInfoInputSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const ListAllowedDirectoriesOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    directories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ListDirectoryOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    path: z.ZodOptional<z.ZodString>;
+    entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        relativePath: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            file: "file";
+            directory: "directory";
+            symlink: "symlink";
+            other: "other";
+        }>;
+        size: z.ZodOptional<z.ZodNumber>;
+        modified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    totalEntries: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SearchFilesOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodOptional<z.ZodNumber>;
+        modified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    totalMatches: z.ZodOptional<z.ZodNumber>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SearchContentOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    matches: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodNumber;
+        content: z.ZodString;
+        contextBefore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contextAfter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    totalMatches: z.ZodOptional<z.ZodNumber>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ReadFileOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    path: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    totalLines: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ReadMultipleFilesOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    summary: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GetFileInfoOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    info: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        type: z.ZodEnum<{
+            file: "file";
+            directory: "directory";
+            symlink: "symlink";
+            other: "other";
+        }>;
+        size: z.ZodNumber;
+        created: z.ZodOptional<z.ZodString>;
+        modified: z.ZodString;
+        accessed: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodString;
+        isHidden: z.ZodOptional<z.ZodBoolean>;
+        mimeType: z.ZodOptional<z.ZodString>;
+        symlinkTarget: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const GetMultipleFileInfoOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        info: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+            type: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+                symlink: "symlink";
+                other: "other";
+            }>;
+            size: z.ZodNumber;
+            created: z.ZodOptional<z.ZodString>;
+            modified: z.ZodString;
+            accessed: z.ZodOptional<z.ZodString>;
+            permissions: z.ZodString;
+            isHidden: z.ZodOptional<z.ZodBoolean>;
+            mimeType: z.ZodOptional<z.ZodString>;
+            symlinkTarget: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    summary: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,eAAO,MAAM,cAAc;;;;;EAAoD,CAAC;AAEhF,eAAO,MAAM,WAAW;;;;;iBAKtB,CAAC;AAEH,eAAO,MAAM,eAAe,yBAKc,CAAC;AAE3C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;iBAYzB,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;kBAuEnC,CAAC;AAEH,eAAO,MAAM,iCAAiC,iCAEX,CAAC;AAEpC,eAAO,MAAM,sBAAsB;;;;kBAuCjC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;kBA4HnC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;kBAW9B,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;kBAUvC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;kBAQjC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;kBASzC,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;iBAI7C,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;iBAgBpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;iBAclC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;iBAgBpC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;iBAO/B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;iBAcxC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa1C,CAAC"}

package/dist/schemas.js

@@ -0,0 +1,379 @@
+import { z } from 'zod';
+function isSafeGlobPattern(value) {
+    if (value.length === 0)
+        return false;
+    const absolutePattern = /^([/\\]|[A-Za-z]:[/\\]|\\\\)/u;
+    if (absolutePattern.test(value)) {
+        return false;
+    }
+    if (/[\\/]\.\.(?:[/\\]|$)/u.test(value) || value.startsWith('..')) {
+        return false;
+    }
+    return true;
+}
+export const FileTypeSchema = z.enum(['file', 'directory', 'symlink', 'other']);
+export const ErrorSchema = z.object({
+    code: z.string().describe('Error code (e.g., E_NOT_FOUND)'),
+    message: z.string().describe('Human-readable error message'),
+    path: z.string().optional().describe('Path that caused the error'),
+    suggestion: z.string().optional().describe('Suggested action to resolve'),
+});
+export const HeadLinesSchema = z
+    .int({ error: 'head must be an integer' })
+    .min(1, 'head must be at least 1')
+    .max(100000, 'head cannot exceed 100,000 lines')
+    .optional()
+    .describe('Read only the first N lines');
+export const FileInfoSchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    type: FileTypeSchema,
+    size: z.number(),
+    created: z.string().optional(),
+    modified: z.string(),
+    accessed: z.string().optional(),
+    permissions: z.string(),
+    isHidden: z.boolean().optional(),
+    mimeType: z.string().optional(),
+    symlinkTarget: z.string().optional(),
+});
+export const OperationSummarySchema = z.object({
+    total: z.number(),
+    succeeded: z.number(),
+    failed: z.number(),
+});
+export const ListDirectoryInputSchema = z.strictObject({
+    path: z
+        .string()
+        .optional()
+        .describe('Directory path to list (leave empty for workspace root). ' +
+        'Examples: "src", "src/components", "lib/utils"'),
+    includeHidden: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Include hidden files and directories'),
+    excludePatterns: z
+        .array(z
+        .string()
+        .min(1, 'Exclude pattern cannot be empty')
+        .max(500, 'Exclude pattern is too long')
+        .refine(isSafeGlobPattern, {
+        error: 'Exclude pattern must be relative (no absolute or ".." segments)',
+    }))
+        .max(100, 'Too many exclude patterns (max 100)')
+        .optional()
+        .default([])
+        .describe('Glob patterns to exclude'),
+    pattern: z
+        .string()
+        .min(1, 'Pattern cannot be empty')
+        .max(1000, 'Pattern is too long (max 1000 characters)')
+        .optional()
+        .refine((value) => value === undefined || isSafeGlobPattern(value), {
+        error: 'Pattern must be relative (no absolute or ".." segments)',
+    })
+        .describe('Glob pattern to include (relative, no "..")'),
+    maxDepth: z
+        .number()
+        .int({ error: 'maxDepth must be an integer' })
+        .min(0, 'maxDepth must be at least 0')
+        .max(100, 'maxDepth cannot exceed 100')
+        .optional()
+        .default(10)
+        .describe('Maximum depth when using pattern (0-100)'),
+    maxEntries: z
+        .number()
+        .int({ error: 'maxEntries must be an integer' })
+        .min(1, 'maxEntries must be at least 1')
+        .max(100000, 'maxEntries cannot exceed 100,000')
+        .optional()
+        .default(10000)
+        .describe('Maximum entries to return (1-100000)'),
+    timeoutMs: z
+        .number()
+        .int({ error: 'timeoutMs must be an integer' })
+        .min(100, 'timeoutMs must be at least 100ms')
+        .max(3600000, 'timeoutMs cannot exceed 1 hour')
+        .optional()
+        .default(30000)
+        .describe('Timeout in milliseconds'),
+    sortBy: z
+        .enum(['name', 'size', 'modified', 'type'])
+        .optional()
+        .default('name')
+        .describe('Sort by: name, size, modified, type'),
+    includeSymlinkTargets: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Include symlink target paths (symlinks are not followed)'),
+});
+export const ListAllowedDirectoriesInputSchema = z
+    .strictObject({})
+    .describe('No input parameters.');
+export const SearchFilesInputSchema = z.strictObject({
+    path: z
+        .string()
+        .optional()
+        .describe('Base directory to search from (leave empty for workspace root). ' +
+        'Examples: "src", "lib", "tests"'),
+    pattern: z
+        .string()
+        .min(1, 'Pattern cannot be empty')
+        .max(1000, 'Pattern is too long (max 1000 characters)')
+        .refine((val) => {
+        try {
+            if (val.includes('**/**/**')) {
+                return false;
+            }
+            return isSafeGlobPattern(val);
+        }
+        catch {
+            return false;
+        }
+    }, {
+        error: 'Invalid glob pattern syntax or unsafe path (absolute/.. segments not allowed)',
+    })
+        .describe('Glob pattern to match files. Examples: "**/*.ts" (all TypeScript files), "src/**/*.js" (JS files in src), "*.json" (JSON files in current dir)'),
+    maxResults: z
+        .number()
+        .int({ error: 'maxResults must be an integer' })
+        .min(1, 'maxResults must be at least 1')
+        .max(10000, 'maxResults cannot exceed 10,000')
+        .optional()
+        .default(100)
+        .describe('Maximum matches to return (1-10000)'),
+});
+export const SearchContentInputSchema = z.strictObject({
+    path: z
+        .string()
+        .optional()
+        .describe('Base directory to search within (leave empty for workspace root). ' +
+        'Examples: "src", "lib", "tests"'),
+    pattern: z
+        .string()
+        .min(1, 'Pattern cannot be empty')
+        .max(1000, 'Pattern is too long (max 1000 characters)')
+        .describe('Text to search for. Examples: "console.log", "import React", "className"'),
+    filePattern: z
+        .string()
+        .min(1, 'File pattern cannot be empty')
+        .max(500, 'File pattern is too long')
+        .optional()
+        .default('**/*')
+        .refine(isSafeGlobPattern, {
+        error: 'File pattern must be relative to the base path (no absolute or ".." segments)',
+    })
+        .describe('Glob pattern to filter files. Examples: "**/*.ts", "src/**/*.js"'),
+    excludePatterns: z
+        .array(z
+        .string()
+        .min(1, 'Exclude pattern cannot be empty')
+        .max(500, 'Exclude pattern is too long')
+        .refine(isSafeGlobPattern, {
+        error: 'Exclude pattern must be relative to the base path (no absolute or ".." segments)',
+    }))
+        .max(100, 'Too many exclude patterns (max 100)')
+        .optional()
+        .describe('Glob patterns to exclude'),
+    caseSensitive: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Case-sensitive search'),
+    maxResults: z
+        .number()
+        .int({ error: 'maxResults must be an integer' })
+        .min(1, 'maxResults must be at least 1')
+        .max(10000, 'maxResults cannot exceed 10,000')
+        .optional()
+        .default(100)
+        .describe('Maximum number of results'),
+    maxFileSize: z
+        .number()
+        .int({ error: 'maxFileSize must be an integer' })
+        .min(1024, 'maxFileSize must be at least 1024 bytes')
+        .max(10 * 1024 * 1024, 'maxFileSize cannot exceed 10MB')
+        .optional()
+        .describe('Maximum file size to scan'),
+    maxFilesScanned: z
+        .number()
+        .int({ error: 'maxFilesScanned must be an integer' })
+        .min(1, 'maxFilesScanned must be at least 1')
+        .max(200000, 'maxFilesScanned cannot exceed 200,000')
+        .optional()
+        .default(20000)
+        .describe('Maximum files to scan before stopping'),
+    timeoutMs: z
+        .number()
+        .int({ error: 'timeoutMs must be an integer' })
+        .min(100, 'timeoutMs must be at least 100ms')
+        .max(3600000, 'timeoutMs cannot exceed 1 hour')
+        .optional()
+        .default(30000)
+        .describe('Timeout in milliseconds'),
+    skipBinary: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('Skip likely-binary files'),
+    includeHidden: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Include hidden files and directories'),
+    contextLines: z
+        .number()
+        .int({ error: 'contextLines must be an integer' })
+        .min(0, 'contextLines must be at least 0')
+        .max(10, 'contextLines cannot exceed 10')
+        .optional()
+        .default(0)
+        .describe('Lines of context before/after match (0-10)'),
+    wholeWord: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Match whole words only'),
+    isLiteral: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Treat pattern as literal string (escape regex chars)'),
+    baseNameMatch: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Match file patterns without slashes against basenames'),
+    caseSensitiveFileMatch: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('Case-sensitive filename matching'),
+    includeIgnored: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Include normally ignored directories (node_modules, dist, .git, etc). ' +
+        'Set to true when debugging in dependencies.'),
+});
+export const ReadFileInputSchema = z.strictObject({
+    path: z
+        .string()
+        .min(1, 'Path cannot be empty')
+        .describe('Path to the file to read. ' +
+        'Examples: "README.md", "src/index.ts", "package.json"'),
+    head: HeadLinesSchema.describe('Read only the first N lines of the file (useful for previewing large files)'),
+});
+export const ReadMultipleFilesInputSchema = z.strictObject({
+    paths: z
+        .array(z.string().min(1, 'Path cannot be empty'))
+        .min(1, 'At least one path is required')
+        .max(100, 'Cannot read more than 100 files at once')
+        .describe('Array of file paths to read. ' +
+        'Examples: ["README.md", "package.json"], ["src/index.ts", "src/server.ts"]'),
+    head: HeadLinesSchema.describe('Read only the first N lines of each file'),
+});
+export const GetFileInfoInputSchema = z.strictObject({
+    path: z
+        .string()
+        .min(1, 'Path cannot be empty')
+        .describe('Path to file or directory. ' +
+        'Examples: "src", "README.md", "src/index.ts"'),
+});
+export const GetMultipleFileInfoInputSchema = z.strictObject({
+    paths: z
+        .array(z.string().min(1, 'Path cannot be empty'))
+        .min(1, 'At least one path is required')
+        .max(100, 'Cannot get info for more than 100 files at once')
+        .describe('Array of file or directory paths. ' +
+        'Examples: ["src", "lib"], ["package.json", "tsconfig.json"]'),
+});
+export const ListAllowedDirectoriesOutputSchema = z.object({
+    ok: z.boolean(),
+    directories: z.array(z.string()).optional(),
+    error: ErrorSchema.optional(),
+});
+export const ListDirectoryOutputSchema = z.object({
+    ok: z.boolean(),
+    path: z.string().optional(),
+    entries: z
+        .array(z.object({
+        name: z.string().describe('Entry name (basename)'),
+        relativePath: z.string().optional(),
+        type: FileTypeSchema,
+        size: z.number().optional(),
+        modified: z.string().optional(),
+    }))
+        .optional(),
+    totalEntries: z.number().optional(),
+    error: ErrorSchema.optional(),
+});
+export const SearchFilesOutputSchema = z.object({
+    ok: z.boolean(),
+    results: z
+        .array(z.object({
+        path: z.string().describe('Relative path from search base'),
+        size: z.number().optional(),
+        modified: z.string().optional(),
+    }))
+        .optional(),
+    totalMatches: z.number().optional(),
+    truncated: z.boolean().optional(),
+    error: ErrorSchema.optional(),
+});
+export const SearchContentOutputSchema = z.object({
+    ok: z.boolean(),
+    matches: z
+        .array(z.object({
+        file: z.string().describe('Relative path from search base'),
+        line: z.number(),
+        content: z.string(),
+        contextBefore: z.array(z.string()).optional(),
+        contextAfter: z.array(z.string()).optional(),
+    }))
+        .optional(),
+    totalMatches: z.number().optional(),
+    truncated: z.boolean().optional(),
+    error: ErrorSchema.optional(),
+});
+export const ReadFileOutputSchema = z.object({
+    ok: z.boolean(),
+    path: z.string().optional(),
+    content: z.string().optional(),
+    truncated: z.boolean().optional(),
+    totalLines: z.number().optional(),
+    error: ErrorSchema.optional(),
+});
+export const ReadMultipleFilesOutputSchema = z.object({
+    ok: z.boolean(),
+    results: z
+        .array(z.object({
+        path: z.string(),
+        content: z.string().optional(),
+        truncated: z.boolean().optional(),
+        error: z.string().optional(),
+    }))
+        .optional(),
+    summary: OperationSummarySchema.optional(),
+    error: ErrorSchema.optional(),
+});
+export const GetFileInfoOutputSchema = z.object({
+    ok: z.boolean(),
+    info: FileInfoSchema.optional(),
+    error: ErrorSchema.optional(),
+});
+export const GetMultipleFileInfoOutputSchema = z.object({
+    ok: z.boolean(),
+    results: z
+        .array(z.object({
+        path: z.string(),
+        info: FileInfoSchema.optional(),
+        error: z.string().optional(),
+    }))
+        .optional(),
+    summary: OperationSummarySchema.optional(),
+    error: ErrorSchema.optional(),
+});
+//# sourceMappingURL=schemas.js.map