fix(amazonq): standardize reference type for reference log (#7311)

## Problem
References are not added to the reference log at the bottom. The root
cause is that the reference tracker log is expecting CW shaped
references, but we are passing "Flare" shaped ones.

## Solution
- Update the reference log to standardize the shape of incoming
references.

## Testing and Verification
- added unit test.
- Verified e2e:


https://github.com/user-attachments/assets/620f6f3d-1205-405e-96a2-322d5e8220c4


- 
---

- Treat all work as PUBLIC. Private `feature/x` branches will not be
squash-merged at release time.
- Your code changes must meet the guidelines in
[CONTRIBUTING.md](https://github.com/aws/aws-toolkit-vscode/blob/master/CONTRIBUTING.md#guidelines).
- License: I confirm that my contribution is made under the terms of the
Apache 2.0 license.

Author: Hweinstock

packages/amazonq/test/unit/codewhisperer/service/referenceLogViewProvider.test.ts

@@ -5,7 +5,6 @@
 import assert from 'assert'
 import { createMockTextEditor, resetCodeWhispererGlobalVariables } from 'aws-core-vscode/test'
 import { ReferenceLogViewProvider, LicenseUtil } from 'aws-core-vscode/codewhisperer'
-
 describe('referenceLogViewProvider', function () {
     beforeEach(async function () {
         await resetCodeWhispererGlobalVariables()
@@ -66,4 +65,39 @@ describe('referenceLogViewProvider', function () {
             assert.ok(!actual.includes(LicenseUtil.getLicenseHtml('MIT')))
         })
     })
+
+    it('accepts references from CW and language server', async function () {
+        const cwReference = {
+            licenseName: 'MIT',
+            repository: 'TEST_REPO',
+            url: 'cw.com',
+            recommendationContentSpan: {
+                start: 0,
+                end: 10,
+            },
+        }
+
+        const flareReference = {
+            referenceName: 'test reference',
+            referenceUrl: 'flare.com',
+            licenseName: 'apache',
+            position: {
+                startCharacter: 0,
+                endCharacter: 10,
+            },
+        }
+
+        const actual = ReferenceLogViewProvider.getReferenceLog(
+            '',
+            [cwReference, flareReference],
+            createMockTextEditor()
+        )
+
+        assert.ok(actual.includes('MIT'))
+        assert.ok(actual.includes('apache'))
+        assert.ok(actual.includes('TEST_REPO'))
+        assert.ok(actual.includes('test reference'))
+        assert.ok(actual.includes('flare.com'))
+        assert.ok(actual.includes('cw.com'))
+    })
 })

packages/core/src/codewhisperer/service/referenceLogViewProvider.ts

@@ -4,13 +4,15 @@
  */
 
 import * as vscode from 'vscode'
-import { References } from '../client/codewhisperer'
 import { LicenseUtil } from '../util/licenseUtil'
 import * as CodeWhispererConstants from '../models/constants'
 import { CodeWhispererSettings } from '../util/codewhispererSettings'
 import globals from '../../shared/extensionGlobals'
 import { AuthUtil } from '../util/authUtil'
 import { session } from '../util/codeWhispererSession'
+import CodeWhispererClient from '../client/codewhispererclient'
+import CodeWhispererUserClient from '../client/codewhispereruserclient'
+import { InlineCompletionItemWithReferences } from '@aws/language-server-runtimes-types'
 
 export class ReferenceLogViewProvider implements vscode.WebviewViewProvider {
     public static readonly viewType = 'aws.codeWhisperer.referenceLog'
@@ -52,28 +54,23 @@ export class ReferenceLogViewProvider implements vscode.WebviewViewProvider {
         }
     }
 
-    public static getReferenceLog(recommendation: string, references: References, editor: vscode.TextEditor): string {
+    public static getReferenceLog(recommendation: string, references: Reference[], editor: vscode.TextEditor): string {
         const filePath = editor.document.uri.path
         const time = new Date().toLocaleString()
         let text = ``
         for (const reference of references) {
+            const standardReference = toStandardReference(reference)
             if (
-                reference.recommendationContentSpan === undefined ||
-                reference.recommendationContentSpan.start === undefined ||
-                reference.recommendationContentSpan.end === undefined
+                standardReference.position === undefined ||
+                standardReference.position.start === undefined ||
+                standardReference.position.end === undefined
             ) {
                 continue
             }
-            const code = recommendation.substring(
-                reference.recommendationContentSpan.start,
-                reference.recommendationContentSpan.end
-            )
-            const firstCharLineNumber =
-                editor.document.positionAt(session.startCursorOffset + reference.recommendationContentSpan.start).line +
-                1
-            const lastCharLineNumber =
-                editor.document.positionAt(session.startCursorOffset + reference.recommendationContentSpan.end - 1)
-                    .line + 1
+            const { start, end } = standardReference.position
+            const code = recommendation.substring(start, end)
+            const firstCharLineNumber = editor.document.positionAt(session.startCursorOffset + start).line + 1
+            const lastCharLineNumber = editor.document.positionAt(session.startCursorOffset + end - 1).line + 1
             let lineInfo = ``
             if (firstCharLineNumber === lastCharLineNumber) {
                 lineInfo = `(line at ${firstCharLineNumber})`
@@ -84,11 +81,11 @@ export class ReferenceLogViewProvider implements vscode.WebviewViewProvider {
                 text += `And `
             }
 
-            let license = `<a href=${LicenseUtil.getLicenseHtml(reference.licenseName)}>${reference.licenseName}</a>`
-            let repository = reference.repository?.length ? reference.repository : 'unknown'
-            if (reference.url?.length) {
-                repository = `<a href=${reference.url}>${reference.repository}</a>`
-                license = `<b><i>${reference.licenseName || 'unknown'}</i></b>`
+            let license = `<a href=${LicenseUtil.getLicenseHtml(standardReference.licenseName)}>${standardReference.licenseName}</a>`
+            let repository = standardReference.repository?.length ? standardReference.repository : 'unknown'
+            if (standardReference.url?.length) {
+                repository = `<a href=${standardReference.url}>${standardReference.repository}</a>`
+                license = `<b><i>${standardReference.licenseName || 'unknown'}</i></b>`
             }
 
             text +=
@@ -144,3 +141,48 @@ export class ReferenceLogViewProvider implements vscode.WebviewViewProvider {
             </html>`
     }
 }
+
+/**
+ * Reference log needs to support references directly from CW, as well as those from Flare. These references have different shapes, so we standarize them here.
+ */
+type GetInnerType<T> = T extends (infer U)[] ? U : never
+type Reference =
+    | CodeWhispererClient.Reference
+    | CodeWhispererUserClient.Reference
+    | GetInnerType<InlineCompletionItemWithReferences['references']>
+
+type StandardizedReference = {
+    licenseName?: string
+    position?: {
+        start?: number
+        end?: number
+    }
+    repository?: string
+    url?: string
+}
+
+/**
+ * Convert a general reference to the standardized format expected by the reference log.
+ * @param ref
+ * @returns
+ */
+function toStandardReference(ref: Reference): StandardizedReference {
+    const isCWReference = (ref: any) => ref.recommendationContentSpan !== undefined
+
+    if (isCWReference(ref)) {
+        const castRef = ref as CodeWhispererClient.Reference
+        return {
+            licenseName: castRef.licenseName!,
+            position: { start: castRef.recommendationContentSpan?.start, end: castRef.recommendationContentSpan?.end },
+            repository: castRef.repository,
+            url: castRef.url,
+        }
+    }
+    const castRef = ref as GetInnerType<InlineCompletionItemWithReferences['references']>
+    return {
+        licenseName: castRef.licenseName,
+        position: { start: castRef.position?.startCharacter, end: castRef.position?.endCharacter },
+        repository: castRef.referenceName,
+        url: castRef.referenceUrl,
+    }
+}