feat(amazonq): enhance workspaceContext classpath generation (aws#1955)

* feat(amazonq): enhance workspaceContext classpath generation

* test(amazonq): add unit test for language detection

Author: liumofei-amazon

server/aws-lsp-codewhisperer/src/language-server/workspaceContext/artifactManager.ts

@@ -6,7 +6,11 @@ import JSZip = require('jszip')
 import { EclipseConfigGenerator, JavaProjectAnalyzer } from './javaManager'
 import { resolveSymlink, isDirectory, isEmptyDirectory } from './util'
 import glob = require('fast-glob')
-import { CodewhispererLanguage, getCodeWhispererLanguageIdFromPath } from '../../shared/languageDetection'
+import {
+    CodewhispererLanguage,
+    getCodeWhispererLanguageIdFromPath,
+    isJavaProjectFileFromPath,
+} from '../../shared/languageDetection'
 
 export interface FileMetadata {
     filePath: string
@@ -627,31 +631,55 @@ export class ArtifactManager {
         files: FileMetadata[]
     ): Promise<FileMetadata[]> {
         const workspacePath = URI.parse(workspaceFolder.uri).path
-        const hasJavaFiles = files.some(file => file.language === 'java')
+        const hasJavaFiles = files.some(file => file.language === 'java' && file.relativePath.endsWith('java'))
 
         if (!hasJavaFiles) {
             return files
         }
 
+        // Extract project roots from file paths for scenarios that workspace were not opened up from project roots
+        const projectRoots = this.extractJavaProjectRoots(files)
         const additionalFiles: FileMetadata[] = []
 
-        // Generate Eclipse configuration files
-        const javaManager = new JavaProjectAnalyzer(workspacePath)
-        const structure = await javaManager.analyze()
-        const generator = new EclipseConfigGenerator(workspaceFolder, this.logging)
+        // Process each project root separately
+        for (const projectRoot of projectRoots) {
+            const isRootProject = projectRoot === '.'
+            const projectPath = path.join(workspacePath, projectRoot)
 
-        // Generate and add .classpath file
-        const classpathFiles = await generator.generateDotClasspath(structure)
-        for (const classpathFile of classpathFiles) {
-            additionalFiles.push(classpathFile)
-        }
+            // Create project-specific "workspace folder" for analyzing
+            const projectWorkspaceFolder: WorkspaceFolder = {
+                ...workspaceFolder,
+                uri: URI.file(projectPath).toString(),
+            }
+
+            const javaManager = new JavaProjectAnalyzer(projectPath)
+            const structure = await javaManager.analyze()
+            const generator = new EclipseConfigGenerator(projectWorkspaceFolder, this.logging)
+
+            const classpathFiles = await generator.generateDotClasspath(structure)
+            const projectConfigFiles = await generator.generateDotProject(
+                isRootProject ? workspaceFolder.name : projectRoot,
+                structure
+            )
+
+            // Update relativePath to include project directory for zip upload
+            const updatedFiles = [...classpathFiles, ...projectConfigFiles].map(file => ({
+                ...file,
+                relativePath: isRootProject ? file.relativePath : path.join(projectRoot, file.relativePath),
+            }))
 
-        // Generate and add .project file
-        const projectFiles = await generator.generateDotProject(path.basename(workspacePath), structure)
-        for (const projectFile of projectFiles) {
-            additionalFiles.push(projectFile)
+            additionalFiles.push(...updatedFiles)
         }
 
         return [...files, ...additionalFiles]
     }
+
+    private extractJavaProjectRoots(files: FileMetadata[]): string[] {
+        const projectRoots = new Set<string>()
+        files
+            .filter(file => isJavaProjectFileFromPath(file.relativePath))
+            .map(file => path.dirname(file.relativePath))
+            .forEach(projectRoot => projectRoots.add(projectRoot))
+        return Array.from(projectRoots)
+    }
 }

server/aws-lsp-codewhisperer/src/shared/languageDetection.test.ts

@@ -5,6 +5,8 @@ import {
     getSupportedLanguageId,
     languageByExtension,
     qLanguageIdByDocumentLanguageId,
+    getCodeWhispererLanguageIdFromPath,
+    isJavaProjectFileFromPath,
 } from './languageDetection'
 
 describe('LanguageDetection', () => {
@@ -40,4 +42,28 @@ describe('LanguageDetection', () => {
             assert.ok(!getSupportedLanguageId(typescriptDocument, ['javascript']))
         })
     })
+
+    describe('getCodeWhispererLanguageIdFromPath', () => {
+        it('should return language type with override', () => {
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/pom.xml'), 'java')
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/build.gradle.kts'), 'java')
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/build.xml'), 'java')
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/build.gradle'), 'java')
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/test.java'), 'java')
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/package.json'), 'javascript')
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/test.js'), 'javascript')
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/test.ts'), 'typescript')
+            assert.strictEqual(getCodeWhispererLanguageIdFromPath('test/test.py'), 'python')
+        })
+    })
+
+    describe('isJavaProjectFileFromPath', () => {
+        it('should return project file as java language', () => {
+            assert.ok(isJavaProjectFileFromPath('test/build.gradle'))
+            assert.ok(isJavaProjectFileFromPath('test/pom.xml'))
+            assert.ok(isJavaProjectFileFromPath('test/build.gradle.kts'))
+            assert.ok(isJavaProjectFileFromPath('test/build.xml'))
+            assert.ok(!isJavaProjectFileFromPath('test/package.json'))
+        })
+    })
 })

server/aws-lsp-codewhisperer/src/shared/languageDetection.ts

@@ -294,6 +294,8 @@ export function getCodeWhispererLanguageIdFromPath(filePath: string): Codewhispe
         return 'javascript'
     }
 
+    if (isJavaProjectFileFromPath(filePath)) return 'java'
+
     for (const [extension, languageId] of Object.entries(languageByExtension)) {
         if (filePath.endsWith(extension)) {
             return getRuntimeLanguage(languageId)
@@ -302,3 +304,25 @@ export function getCodeWhispererLanguageIdFromPath(filePath: string): Codewhispe
 
     return undefined
 }
+
+/**
+ * For project context we're treating these file name as java project file to be uploaded to container & using it's location to identify java roots
+ * Kotlin may also have these file but for project context we're only considering it for java until we have language support for kotlin
+ * @param filePath
+ * @returns boolean indicate the java file override
+ *
+ * @example
+ * // Returns 'true' for a build.gradle file
+ * isJavaProjectFileFromPath('src/build.gradle')
+ *
+ * @remarks
+ * - This function is extension-based only
+ */
+export function isJavaProjectFileFromPath(filePath: string): boolean {
+    return (
+        filePath.endsWith(`build.gradle`) ||
+        filePath.endsWith(`build.gradle.kts`) ||
+        filePath.endsWith(`pom.xml`) ||
+        filePath.endsWith(`build.xml`)
+    )
+}