feat: port listDirectory from VSC (#930)

* feat: port readDirectoryRecursively from VSC

* test: avoid duplicate length checks

* fix: account for different node versions

* fix: avoid duplication in the tests

* fix: implement workaround everywhere

* feat: port tool with minimal changes from VSC

* feat: make fatal errors optional

* refactor: avoid adding errors to results

* test: skip permissions test on windows

* refactor: fixup implementation to follow flare agent interface

* test: enable all tests

* test: add type assertion to avoid error

Author: Hweinstock

core/aws-lsp-core/src/index.ts

@@ -15,4 +15,5 @@ export * as timeoutUtils from './util/timeoutUtils'
 export * from './util/awsError'
 export * from './base/index'
 export * as testFolder from './test/testFolder'
+export * as workspaceUtils from './util/workspaceUtils'
 export * as processUtils from './util/processUtils'

core/aws-lsp-core/src/util/workspaceUtils.ts

@@ -6,7 +6,7 @@ type Dirent = ElementType<Awaited<ReturnType<Features['workspace']['fs']['readdi
 
 // Port of https://github.com/aws/aws-toolkit-vscode/blob/dfee9f7a400e677e91a75e9c20d9515a52a6fad4/packages/core/src/shared/utilities/workspaceUtils.ts#L699
 export async function readDirectoryRecursively(
-    features: Features,
+    features: Pick<Features, 'workspace' | 'logging'> & Partial<Features>,
     folderPath: string,
     options?: {
         maxDepth?: number

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/listDirectory.test.ts

@@ -0,0 +1,85 @@
+import * as assert from 'assert'
+import { Writable } from 'stream'
+import { ListDirectory } from './listDirectory'
+import { testFolder } from '@aws/lsp-core'
+import * as path from 'path'
+import * as fs from 'fs/promises'
+import { TestFeatures } from '@aws/language-server-runtimes/testing'
+import { Features } from '@aws/language-server-runtimes/server-interface/server'
+
+describe('ListDirectory Tool', () => {
+    let tempFolder: testFolder.TestFolder
+    let testFeatures: TestFeatures
+
+    before(async () => {
+        testFeatures = new TestFeatures()
+        // @ts-ignore does not require all fs operations to be implemented
+        testFeatures.workspace.fs = {
+            exists: path =>
+                fs
+                    .access(path)
+                    .then(() => true)
+                    .catch(() => false),
+            readdir: path => fs.readdir(path, { withFileTypes: true }),
+        } as Features['workspace']['fs']
+        tempFolder = await testFolder.TestFolder.create()
+    })
+
+    after(async () => {
+        await tempFolder.delete()
+    })
+
+    it('lists directory contents', async () => {
+        await tempFolder.nest('subfolder')
+        await tempFolder.write('fileA.txt', 'fileA content')
+
+        const listDirectory = new ListDirectory(testFeatures)
+        const result = await listDirectory.invoke({ path: tempFolder.path, maxDepth: 0 })
+
+        assert.strictEqual(result.output.kind, 'text')
+        const lines = result.output.content.split('\n')
+        const hasFileA = lines.some((line: string | string[]) => line.includes('[FILE] ') && line.includes('fileA.txt'))
+        const hasSubfolder = lines.some(
+            (line: string | string[]) => line.includes('[DIR] ') && line.includes('subfolder')
+        )
+
+        assert.ok(hasFileA, 'Should list fileA.txt in the directory output')
+        assert.ok(hasSubfolder, 'Should list the subfolder in the directory output')
+    })
+
+    it('lists directory contents recursively', async () => {
+        await tempFolder.nest('subfolder')
+        await tempFolder.write('fileA.txt', 'fileA content')
+        await tempFolder.write(path.join('subfolder', 'fileB.md'), '# fileB')
+
+        const listDirectory = new ListDirectory(testFeatures)
+        const result = await listDirectory.invoke({ path: tempFolder.path })
+
+        assert.strictEqual(result.output.kind, 'text')
+        const lines = result.output.content.split('\n')
+        const hasFileA = lines.some((line: string | string[]) => line.includes('[FILE] ') && line.includes('fileA.txt'))
+        const hasSubfolder = lines.some(
+            (line: string | string[]) => line.includes('[DIR] ') && line.includes('subfolder')
+        )
+        const hasFileB = lines.some((line: string | string[]) => line.includes('[FILE] ') && line.includes('fileB.md'))
+
+        assert.ok(hasFileA, 'Should list fileA.txt in the directory output')
+        assert.ok(hasSubfolder, 'Should list the subfolder in the directory output')
+        assert.ok(hasFileB, 'Should list fileB.md in the subfolder in the directory output')
+    })
+
+    it('throws error if path does not exist', async () => {
+        const missingPath = path.join(tempFolder.path, 'no_such_file.txt')
+        const listDirectory = new ListDirectory(testFeatures)
+
+        await assert.rejects(listDirectory.invoke({ path: missingPath, maxDepth: 0 }))
+    })
+
+    it('expands ~ path', async () => {
+        const listDirectory = new ListDirectory(testFeatures)
+        const result = await listDirectory.invoke({ path: '~', maxDepth: 0 })
+
+        assert.strictEqual(result.output.kind, 'text')
+        assert.ok(result.output.content.length > 0)
+    })
+})

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/listDirectory.ts

@@ -0,0 +1,80 @@
+// VSC Port from https://github.com/aws/aws-toolkit-vscode/blob/dfee9f7a400e677e91a75e9c20d9515a52a6fad4/packages/core/src/codewhispererChat/tools/listDirectory.ts#L18
+import { InvokeOutput } from './toolShared'
+import { workspaceUtils } from '@aws/lsp-core'
+import { Features } from '@aws/language-server-runtimes/server-interface/server'
+import { sanitize } from '@aws/lsp-core/out/util/path'
+
+export interface ListDirectoryParams {
+    path: string
+    maxDepth?: number
+}
+
+export class ListDirectory {
+    private readonly logging: Features['logging']
+    private readonly workspace: Features['workspace']
+
+    constructor(features: Pick<Features, 'logging' | 'workspace'>) {
+        this.logging = features.logging
+        this.workspace = features.workspace
+    }
+
+    public async queueDescription(params: ListDirectoryParams, updates: WritableStream) {
+        const writer = updates.getWriter()
+        if (params.maxDepth === undefined) {
+            await writer.write(`Listing directory recursively: ${params.path}`)
+        } else if (params.maxDepth === 0) {
+            await writer.write(`Listing directory: ${params.path}`)
+        } else {
+            const level = params.maxDepth > 1 ? 'levels' : 'level'
+            await writer.write(`Listing directory: ${params.path} limited to ${params.maxDepth} subfolder ${level}`)
+        }
+        await writer.close()
+    }
+
+    public async invoke(params: ListDirectoryParams): Promise<InvokeOutput> {
+        const path = sanitize(params.path)
+        try {
+            const listing = await workspaceUtils.readDirectoryRecursively(
+                { workspace: this.workspace, logging: this.logging },
+                path,
+                { maxDepth: params.maxDepth }
+            )
+            return this.createOutput(listing.join('\n'))
+        } catch (error: any) {
+            this.logging.error(`Failed to list directory "${path}": ${error.message || error}`)
+            throw new Error(`Failed to list directory "${path}": ${error.message || error}`)
+        }
+    }
+
+    private createOutput(content: string): InvokeOutput {
+        return {
+            output: {
+                kind: 'text',
+                content: content,
+            },
+        }
+    }
+
+    public getSpec() {
+        return {
+            name: 'listDirectory',
+            description:
+                'List the contents of a directory and its subdirectories.\n * Use this tool for discovery, before using more targeted tools like fsRead.\n *Useful to try to understand the file structure before diving deeper into specific files.\n *Can be used to explore the codebase.\n *Results clearly distinguish between files, directories or symlinks with [FILE], [DIR] and [LINK] prefixes.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Absolute path to a directory, e.g., `/repo`.',
+                    },
+                    maxDepth: {
+                        type: 'number',
+                        description:
+                            'Maximum depth to traverse when listing directories. Use `0` to list only the specified directory, `1` to include immediate subdirectories, etc. If it is not provided, it will list all subdirectories recursively.',
+                    },
+                },
+                required: ['path'],
+            },
+        } as const
+    }
+}

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/toolServer.ts

@@ -1,16 +1,21 @@
 import { Server } from '@aws/language-server-runtimes/server-interface'
 import { FsRead, FsReadParams } from './fsRead'
 import { FsWrite, FsWriteParams } from './fsWrite'
+import { ListDirectory, ListDirectoryParams } from './listDirectory'
 import { ExecuteBash, ExecuteBashParams } from './executeBash'
 
 export const FsToolsServer: Server = ({ workspace, logging, agent }) => {
     const fsReadTool = new FsRead({ workspace, logging })
     const fsWriteTool = new FsWrite({ workspace, logging })
 
+    const listDirectoryTool = new ListDirectory({ workspace, logging })
+
     agent.addTool(fsReadTool.getSpec(), (input: FsReadParams) => fsReadTool.invoke(input))
 
     agent.addTool(fsWriteTool.getSpec(), (input: FsWriteParams) => fsWriteTool.invoke(input))
 
+    agent.addTool(listDirectoryTool.getSpec(), (input: ListDirectoryParams) => listDirectoryTool.invoke(input))
+
     return () => {}
 }