Add recursive depth dir listing (#250)

Author: wonderwhy-er

package-lock.json

@@ -209,10 +209,15 @@ export async function handleCreateDirectory(args: unknown): Promise<ServerResult
  */
 export async function handleListDirectory(args: unknown): Promise<ServerResult> {
     try {
+        const startTime = Date.now();
         const parsed = ListDirectoryArgsSchema.parse(args);
-        const entries = await listDirectory(parsed.path);
+        const entries = await listDirectory(parsed.path, parsed.depth);
+        const duration = Date.now() - startTime;
+
+        const resultText = entries.join('\n');
+
         return {
-            content: [{ type: "text", text: entries.join('\n') }],
+            content: [{ type: "text", text: resultText }],
         };
     } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

src/handlers/filesystem-handlers.ts

@@ -324,6 +324,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         Use this instead of 'execute_command' with ls/dir commands.
                         Results distinguish between files and directories with [FILE] and [DIR] prefixes.
+                        
+                        Supports recursive listing with the 'depth' parameter (default: 2):
+                        - depth=1: Only direct contents of the directory
+                        - depth=2: Contents plus one level of subdirectories
+                        - depth=3+: Multiple levels deep
+                        
+                        Results show full relative paths from the root directory being listed.
+                        Example output with depth=2:
+                        [DIR] src
+                        [FILE] src/index.ts
+                        [DIR] src/tools
+                        [FILE] src/tools/filesystem.ts
+                        
+                        If a directory cannot be accessed, it will show [DENIED] instead.
                         Only works within allowed directories.
                         
                         ${PATH_GUIDANCE}

src/server.ts

@@ -890,10 +890,47 @@ export async function createDirectory(dirPath: string): Promise<void> {
     await fs.mkdir(validPath, { recursive: true });
 }
 
-export async function listDirectory(dirPath: string): Promise<string[]> {
+export async function listDirectory(dirPath: string, depth: number = 2): Promise<string[]> {
     const validPath = await validatePath(dirPath);
-    const entries = await fs.readdir(validPath, { withFileTypes: true });
-    return entries.map((entry) => `${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}`);
+    const results: string[] = [];
+
+    async function listRecursive(currentPath: string, currentDepth: number, relativePath: string = ''): Promise<void> {
+        if (currentDepth <= 0) return;
+
+        let entries;
+        try {
+            entries = await fs.readdir(currentPath, { withFileTypes: true });
+        } catch (error) {
+            // If we can't read this directory (permission denied), show as denied
+            const displayPath = relativePath || path.basename(currentPath);
+            results.push(`[DENIED] ${displayPath}`);
+            return;
+        }
+
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            const displayPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+
+            // Add this entry to results
+            results.push(`${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${displayPath}`);
+
+            // If it's a directory and we have depth remaining, recurse
+            if (entry.isDirectory() && currentDepth > 1) {
+                try {
+                    // Validate the path before recursing
+                    await validatePath(fullPath);
+                    await listRecursive(fullPath, currentDepth - 1, displayPath);
+                } catch (error) {
+                    // If validation fails or we can't access it, it will be marked as denied
+                    // when we try to read it in the recursive call
+                    continue;
+                }
+            }
+        }
+    }
+
+    await listRecursive(validPath, depth);
+    return results;
 }
 
 export async function moveFile(sourcePath: string, destinationPath: string): Promise<void> {

src/tools/filesystem.ts

@@ -63,6 +63,7 @@ export const CreateDirectoryArgsSchema = z.object({
 
 export const ListDirectoryArgsSchema = z.object({
   path: z.string(),
+  depth: z.number().optional().default(2),
 });
 
 export const MoveFileArgsSchema = z.object({