[AXON-385] Use JIRA AI to populate createIssueView fileds

Author: sdzh-atlassian

e2e/tsconfig.e2e.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+        "baseUrl": ".",
+        "outDir": "../.generated",
+        "module": "CommonJS",
+        "target": "es2018",
+        "lib": ["ESNext", "dom"],
+        "alwaysStrict": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "sourceMap": true,
+        "allowJs": true,
+        "jsx": "react",
+        "moduleResolution": "node",
+        "rootDir": "../..",
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "noUnusedLocals": true,
+        "noFallthroughCasesInSwitch": true,
+        "strictPropertyInitialization": true,
+        "typeRoots": ["node_modules/@types", "src/typings/"],
+        "paths": {
+            "testsutil/*": ["testsutil/*"]
+        }
+    },
+    "include": ["tests/**/*"]
+}

package.json

@@ -809,6 +809,21 @@
             "type": "object",
             "title": "Atlassian",
             "properties": {
+                "atlascode.issueSuggestion.enabled": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Enables AI-assisted issue suggestion for TODO comments",
+                    "scope": "window"
+                },
+                "atlascode.issueSuggestion.contextLevel": {
+                    "type": "string",
+                    "description": "What context to use for issue suggestions - only the TODO text, surrouding code, or the entire file",
+                    "default": "codeContext",
+                    "enum": [
+                        "todoOnly",
+                        "codeContext"
+                    ]
+                },
                 "atlascode.outputLevel": {
                     "type": "string",
                     "default": "silent",

src/atlclients/issueBuilder.ts

@@ -0,0 +1,116 @@
+import { AxiosInstance } from 'axios';
+import { Container } from 'src/container';
+
+import { getAxiosInstance } from '../jira/jira-client/providers';
+import { BasicAuthInfo, DetailedSiteInfo, isBasicAuthInfo, ProductJira } from './authInfo';
+
+export type SuggestedIssue = {
+    issueType: string;
+    fieldValues: {
+        summary: string;
+        description: string;
+    };
+};
+
+export type SuggestedIssuesResponse = {
+    suggestedIssues: SuggestedIssue[];
+};
+
+export const findCloudSiteWithApiKey = async (): Promise<DetailedSiteInfo | null> => {
+    const sites = await Promise.all(
+        Container.siteManager.getSitesAvailable(ProductJira).map(async (site) => {
+            if (!site.host.endsWith('.atlassian.net')) {
+                return null;
+            }
+
+            const authInfo = await Container.credentialManager.getAuthInfo(site);
+            if (!authInfo || !isBasicAuthInfo(authInfo)) {
+                return null;
+            }
+
+            return site;
+        }),
+    ).then((results) => results.filter(Boolean));
+
+    // Any site is fine, just need an API key
+    const site = sites[0];
+    return site;
+};
+
+export const fetchIssueSuggestions = async (prompt: string): Promise<SuggestedIssuesResponse> => {
+    const axiosInstance: AxiosInstance = getAxiosInstance();
+
+    try {
+        const site = await findCloudSiteWithApiKey();
+
+        if (!site) {
+            throw new Error('No site found with API key');
+        }
+
+        const authInfo = (await Container.credentialManager.getAuthInfo(site)) as BasicAuthInfo;
+        if (!authInfo || !isBasicAuthInfo(authInfo)) {
+            throw new Error('No valid auth info found for site');
+        }
+
+        const response = await axiosInstance.post(
+            `https://${site.host}/gateway/api/assist/chat/v1/invoke_agent`,
+            {
+                recipient_agent_named_id: 'ai_issue_create_agent',
+                agent_input_context: {
+                    application: 'Slack',
+                    context: {
+                        primary_message: { text: prompt },
+                    },
+                    suggested_issues_config: {
+                        max_issues: 1,
+                        suggested_issue_field_types: [
+                            {
+                                issue_type: 'Task',
+                                fields: [
+                                    {
+                                        field_name: 'Summary',
+                                        field_type: 'Short-Text',
+                                    },
+                                    {
+                                        field_name: 'Description',
+                                        field_type: 'Paragraph',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+            {
+                headers: {
+                    'Content-Type': 'application/json;charset=UTF-8',
+                    Accept: 'application/json;charset=UTF-8',
+                    'X-Experience-Id': 'ai-issue-create-slack',
+                    'X-Product': 'jira',
+                    Authorization:
+                        'Basic ' + Buffer.from(`${authInfo.username}:${authInfo.password}`).toString('base64'),
+                },
+            },
+        );
+        const content = JSON.parse(response.data.message.content);
+
+        const responseData: SuggestedIssuesResponse = {
+            suggestedIssues: content.suggested_issues.map((issue: any) => ({
+                issueType: issue.issue_type,
+                fieldValues: {
+                    summary: issue.field_values.Summary,
+                    description: issue.field_values.Description,
+                },
+            })),
+        };
+
+        if (!responseData.suggestedIssues || responseData.suggestedIssues.length === 0) {
+            throw new Error('No suggested issues found');
+        }
+
+        return responseData;
+    } catch (error) {
+        console.error('Error fetching issue suggestions:', error);
+        throw error;
+    }
+};

src/commands.ts

@@ -171,7 +171,7 @@ export function registerCommands(vscodeContext: ExtensionContext) {
                 }
             },
         ),
-        commands.registerCommand(Commands.CreateIssue, (data: any, source?: string) => createIssue(data, source)),
+        commands.registerCommand(Commands.CreateIssue, async (data: any, source?: string) => createIssue(data, source)),
         commands.registerCommand(
             Commands.ShowIssue,
             async (issueOrKeyAndSite: MinimalIssueOrKeyAndSite<DetailedSiteInfo>) => await showIssue(issueOrKeyAndSite),

src/commands/jira/createIssue.ts

@@ -1,32 +1,72 @@
+import { SimplifiedTodoIssueData } from 'src/config/model';
+import { Logger } from 'src/logger';
 import { Position, Range, Uri, ViewColumn, window, workspace, WorkspaceEdit } from 'vscode';
 
 import { startIssueCreationEvent } from '../../analytics';
 import { ProductJira } from '../../atlclients/authInfo';
 import { WorkspaceRepo } from '../../bitbucket/model';
 import { Container } from '../../container';
 import { CommentData } from '../../webviews/createIssueWebview';
+import { IssueSuggestionManager } from './issueSuggestionManager';
 
 export interface TodoIssueData {
     summary: string;
     uri: Uri;
     insertionPoint: Position;
+    context: string;
 }
 
-export function createIssue(data: Uri | TodoIssueData | undefined, source?: string) {
+const simplify = (data: TodoIssueData): SimplifiedTodoIssueData => {
+    return {
+        summary: data.summary,
+        context: data.context,
+        position: {
+            line: data.insertionPoint.line,
+            character: data.insertionPoint.character,
+        },
+        uri: data.uri.toString(),
+    };
+};
+
+export async function createIssue(data: Uri | TodoIssueData | undefined, source?: string) {
     if (isTodoIssueData(data)) {
-        const partialIssue = {
-            summary: data.summary,
-            description: descriptionForUri(data.uri),
-            uri: data.uri,
-            position: data.insertionPoint,
-            onCreated: annotateComment,
-        };
-        Container.createIssueWebview.createOrShow(ViewColumn.Beside, partialIssue);
+        const settings = await IssueSuggestionManager.buildSettings();
+        const todoData = simplify(data);
+
+        await Container.createIssueWebview.createOrShow(
+            ViewColumn.Beside,
+            {
+                description: descriptionForUri(data.uri),
+                uri: data.uri,
+                position: data.insertionPoint,
+                onCreated: annotateComment,
+            },
+            settings,
+            todoData,
+        );
+
+        try {
+            const suggestionManager = new IssueSuggestionManager(settings);
+
+            await suggestionManager.generate(todoData).then(async (suggestion) => {
+                await Container.createIssueWebview.forceUpdateFields({
+                    summary: suggestion.summary,
+                    description: suggestion.description,
+                });
+            });
+        } catch (error) {
+            // The view is already created with legacy logic, do nothing
+            Logger.error(error, 'Error generating issue suggestion settings');
+        }
+
         startIssueCreationEvent('todoComment', ProductJira).then((e) => {
             Container.analyticsClient.sendTrackEvent(e);
         });
+
         return;
-    } else if (isUri(data) && data.scheme === 'file') {
+    }
+
+    if (isUri(data) && data.scheme === 'file') {
         Container.createIssueWebview.createOrShow(ViewColumn.Active, { description: descriptionForUri(data) });
         startIssueCreationEvent('contextMenu', ProductJira).then((e) => {
             Container.analyticsClient.sendTrackEvent(e);

src/commands/jira/issueSuggestionManager.ts

@@ -0,0 +1,112 @@
+import { FeatureFlagClient, Features } from 'src/util/featureFlags';
+import { window, workspace } from 'vscode';
+
+import { fetchIssueSuggestions, findCloudSiteWithApiKey } from '../../atlclients/issueBuilder';
+import { IssueSuggestionContextLevel, IssueSuggestionSettings, SimplifiedTodoIssueData } from '../../config/model';
+
+export class IssueSuggestionManager {
+    static getSuggestionEnabled(): boolean {
+        const config = workspace.getConfiguration('atlascode.issueSuggestion').get<boolean>('enabled');
+        return config === true; // (as opposed to undefined)
+    }
+
+    static getSuggestionContextLevel(): IssueSuggestionContextLevel {
+        const config = workspace
+            .getConfiguration('atlascode')
+            .get<IssueSuggestionContextLevel>('issueSuggestion.contextLevel');
+
+        return config || IssueSuggestionContextLevel.CodeContext;
+    }
+
+    static async getSuggestionAvailable(): Promise<boolean> {
+        return FeatureFlagClient.checkGate(Features.EnableAiSuggestions) && (await findCloudSiteWithApiKey()) !== null;
+    }
+
+    static async buildSettings(): Promise<IssueSuggestionSettings> {
+        const isSuggestionEnabled = this.getSuggestionEnabled();
+        const contextLevel = this.getSuggestionContextLevel();
+        const isSuggestionAvailable = await this.getSuggestionAvailable();
+
+        return {
+            isAvailable: isSuggestionAvailable,
+            isEnabled: isSuggestionEnabled,
+            level: contextLevel,
+        };
+    }
+
+    constructor(private readonly settings: IssueSuggestionSettings) {}
+
+    createSuggestionPrompt(data: SimplifiedTodoIssueData, contextLevel?: IssueSuggestionContextLevel): string {
+        if (!contextLevel) {
+            throw new Error('Context level is not defined');
+        }
+
+        switch (contextLevel) {
+            case IssueSuggestionContextLevel.TodoOnly: {
+                return `Create a Jira issue based on the following TODO comment:\n\n${data.summary}`;
+            }
+            case IssueSuggestionContextLevel.CodeContext: {
+                return `Create a Jira issue based on the following TODO comment:\n\n${data.summary}. The code context in which it appears is:\n\n${data.context}`;
+            }
+            default:
+                throw new Error(`Unknown context level: ${contextLevel}`);
+        }
+    }
+
+    getSuggestionSettings(): IssueSuggestionSettings {
+        return this.settings;
+    }
+
+    async generateIssueSuggestion(data: SimplifiedTodoIssueData) {
+        const prompt = this.createSuggestionPrompt(data, this.settings.level);
+        try {
+            const response = await fetchIssueSuggestions(prompt);
+            const issue = response.suggestedIssues[0];
+            if (!issue) {
+                return {
+                    summary: '',
+                    description: '',
+                    error: 'Unable to fetch issue suggestions. Sorry!',
+                };
+            }
+            return {
+                summary: issue.fieldValues.summary,
+                description: issue.fieldValues.description,
+                error: '',
+            };
+        } catch (error) {
+            console.error('Error fetching issue suggestions:', error);
+            window.showErrorMessage('Error fetching issue suggestions: ' + error.message);
+            return {
+                summary: '',
+                description: '',
+                error: 'Error fetching issue suggestions: ' + error.message,
+            };
+        }
+    }
+
+    async generateDummyIssueSuggestion(data: SimplifiedTodoIssueData) {
+        return {
+            summary: data.summary,
+            description: `File: ${data.uri}\nLine: ${data.position.line}`,
+        };
+    }
+
+    async generate(data: SimplifiedTodoIssueData) {
+        return this.settings.isEnabled ? this.generateIssueSuggestion(data) : this.generateDummyIssueSuggestion(data);
+    }
+
+    async sendFeedback(isPositive: boolean, data: SimplifiedTodoIssueData) {
+        const feedback = isPositive
+            ? `Positive feedback for issue suggestion: ${data.summary}`
+            : `Negative feedback for issue suggestion: ${data.summary}`;
+        console.log('Sending feedback:', feedback);
+        try {
+            // TODO: actually send an analytics event
+            window.showInformationMessage(`Thank you for your feedback!`);
+        } catch (error) {
+            console.error('Error sending feedback:', error);
+            window.showErrorMessage('Error sending feedback: ' + error.message);
+        }
+    }
+}