gaunt-sloth-assistant 0.0.8 → 0.1.1

package/spec/reviewCommand.spec.js

@@ -0,0 +1,144 @@
+import {Command} from 'commander';
+import * as td from 'testdouble';
+
+describe('reviewCommand',  function (){
+
+    beforeEach(async function() {
+        this.review = td.function();
+        this.prompt = await td.replaceEsm("../src/prompt.js");
+        td.when(this.prompt.readInternalPreamble()).thenReturn("INTERNAL PREAMBLE");
+        td.when(this.prompt.readPreamble(".gsloth.preamble.review.md")).thenReturn("PROJECT PREAMBLE");
+        this.codeReviewMock = await td.replaceEsm("../src/modules/reviewModule.js");
+        await td.replaceEsm("../src/config.js");
+        this.utils = await td.replaceEsm("../src/utils.js");
+        td.when(this.utils.readFileFromCurrentDir("test.file")).thenReturn("FILE TO REVIEW");
+        td.when(this.codeReviewMock.review(
+            'sloth-DIFF-review',
+            td.matchers.anything(),
+            td.matchers.anything())
+        ).thenDo(this.review);
+    });
+
+    it('Should call review with file contents', async function() {
+        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
+        const program = new Command()
+        await reviewCommand(program, {});
+        await program.parseAsync(['na', 'na', 'review', '-f', 'test.file']);
+        td.verify(this.review(
+            'sloth-DIFF-review',
+            "INTERNAL PREAMBLE\nPROJECT PREAMBLE",
+            "test.file:\n```\nFILE TO REVIEW\n```")
+        );
+    });
+
+    it('Should display predefined providers in help', async function() {
+        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
+        const program = new Command();
+        const testOutput = { text: '' };
+
+        program.configureOutput({
+            writeOut: (str) => testOutput.text += str,
+            writeErr: (str) => testOutput.text += str
+        });
+
+        await reviewCommand(program, {});
+
+        const commandUnderTest = program.commands.find(c => c.name() == 'review');
+        expect(commandUnderTest).toBeDefined();
+        commandUnderTest.outputHelp();
+
+        // Verify content providers are displayed
+        expect(testOutput.text).toContain('--content-provider <contentProvider>');
+        expect(testOutput.text).toContain('(choices: "gh", "text")');
+
+        // Verify requirements providers are displayed
+        expect(testOutput.text).toContain('--requirements-provider <requirementsProvider>');
+        expect(testOutput.text).toContain('(choices: "jira-legacy", "text")');
+    });
+
+    it('Should call review with predefined requirements provider', async function() {
+        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
+        const program = new Command();
+        const context = {
+            config: {
+                requirementsProvider: 'jira-legacy',
+                requirementsProviderConfig: {
+                    'jira-legacy': {
+                        username: 'test-user',
+                        token: 'test-token',
+                        baseUrl: 'https://test-jira.atlassian.net/rest/api/2/issue/'
+                    }
+                }
+            }
+        };
+
+        // Mock the jira provider
+        const jiraProvider = td.func();
+        td.when(jiraProvider(td.matchers.anything(), 'JIRA-123')).thenResolve('JIRA Requirements');
+
+        // Replace the dynamic import with our mock
+        await td.replaceEsm('../src/providers/jiraIssueLegacyAccessTokenProvider.js', {
+            get: jiraProvider
+        });
+
+        await reviewCommand(program, context);
+        await program.parseAsync(['na', 'na', 'review', 'content-id', '-r', 'JIRA-123']);
+
+        td.verify(this.review('sloth-DIFF-review', "INTERNAL PREAMBLE\nPROJECT PREAMBLE", "JIRA Requirements"));
+    });
+
+    it('Should call review with predefined content provider', async function() {
+        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
+        const program = new Command();
+        const context = {
+            config: {
+                contentProvider: 'gh'
+            }
+        };
+
+        // Mock the gh provider
+        const ghProvider = td.func();
+        td.when(ghProvider(td.matchers.anything(), '123')).thenResolve('PR Diff Content');
+
+        // Replace the dynamic import with our mock
+        await td.replaceEsm('../src/providers/ghPrDiffProvider.js', {
+            get: ghProvider
+        });
+
+        await reviewCommand(program, context);
+        await program.parseAsync(['na', 'na', 'review', '123']);
+
+        td.verify(this.review('sloth-DIFF-review', "INTERNAL PREAMBLE\nPROJECT PREAMBLE", "PR Diff Content"));
+    });
+
+    it('Should call pr command', async function() {
+        // Create a spy for the review function
+        const reviewSpy = td.func();
+
+        // Replace the review function in the codeReviewMock
+        this.codeReviewMock.review = reviewSpy;
+
+        // Mock the modules/reviewModule.js import in the reviewCommand.js file
+        await td.replaceEsm('../src/modules/reviewModule.js', {
+            review: reviewSpy
+        });
+
+        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
+        const program = new Command();
+        const context = {};
+
+        // Mock the gh provider
+        const ghProvider = td.func();
+        td.when(ghProvider('123')).thenResolve('PR Diff Content');
+
+        // Replace the dynamic import with our mock
+        await td.replaceEsm('../src/providers/ghPrDiffProvider.js', {
+            get: ghProvider
+        });
+
+        await reviewCommand(program, context);
+        await program.parseAsync(['na', 'na', 'pr', '123']);
+
+        td.verify(reviewSpy('sloth-PR-123-review', "INTERNAL PREAMBLE\nPROJECT PREAMBLE", "PR Diff Content"));
+    });
+});

package/spec/{codeReview.spec.js → reviewModule.spec.js}

@@ -1,8 +1,8 @@
-import { reviewInner } from '../src/codeReview.js';
+import { reviewInner } from '../src/modules/reviewModule.js';
 import { slothContext } from '../src/config.js';
 import { FakeListChatModel } from "@langchain/core/utils/testing";
 
-describe('codeReview', () => {
+describe('reviewModule', () => {
 
   it('should invoke LLM', async () => {
     // Setup mock for slothContext

package/src/commands/askCommand.js

@@ -0,0 +1,26 @@
+import { readInternalPreamble } from "../prompt.js";
+import { readFileFromCurrentDir } from "../utils.js";
+import { initConfig } from "../config.js";
+
+/**
+ * Adds the ask command to the program
+ * @param {Object} program - The commander program
+ * @param {Object} context - The context object
+ */
+export function askCommand(program, context) {
+    program.command('ask')
+        .description('Ask a question')
+        .argument('<message>', 'A message')
+        .option('-f, --file <file>', 'Input file. Content of this file will be added BEFORE the diff')
+        // TODO add option consuming extra message as argument
+        .action(async (message, options) => {
+            const preamble = [readInternalPreamble()];
+            const content = [message];
+            if (options.file) {
+                content.push(readFileFromCurrentDir(options.file));
+            }
+            await initConfig();
+            const { askQuestion } = await import('../modules/questionAnsweringModule.js');
+            await askQuestion('sloth-ASK', preamble.join("\n"), content.join("\n"));
+        });
+}

package/src/commands/initCommand.js

@@ -0,0 +1,16 @@
+import { Argument } from 'commander';
+import { availableDefaultConfigs, createProjectConfig } from "../config.js";
+
+/**
+ * Adds the init command to the program
+ * @param {Object} program - The commander program
+ * @param {Object} context - The context object
+ */
+export function initCommand(program, context) {
+    program.command('init')
+        .description('Initialize the Gaunt Sloth Assistant in your project. This will write necessary config files.')
+        .addArgument(new Argument('<type>', 'Config type').choices(availableDefaultConfigs))
+        .action(async (config) => {
+            await createProjectConfig(config);
+        });
+}

package/src/commands/reviewCommand.js

@@ -0,0 +1,147 @@
+import {Option} from 'commander';
+import {USER_PROJECT_REVIEW_PREAMBLE} from "../config.js";
+import {readInternalPreamble, readPreamble} from "../prompt.js";
+import {readFileFromCurrentDir} from "../utils.js";
+import {displayError} from "../consoleUtils.js";
+
+/**
+ * Requirements providers. Expected to be in `.providers/` dir
+ */
+const REQUIREMENTS_PROVIDERS = {
+    'jira-legacy': 'jiraIssueLegacyAccessTokenProvider.js',
+    'text': 'text.js'
+};
+
+/**
+ * Content providers. Expected to be in `.providers/` dir
+ */
+const CONTENT_PROVIDERS = {
+    'gh': 'ghPrDiffProvider.js',
+    'text': 'text.js'
+};
+
+export function reviewCommand(program, context) {
+
+    program.command('review')
+        .description('Review provided diff or other content')
+        .argument('[contentId]', 'Optional content ID argument to retrieve content with content provider')
+        .alias('r')
+        // TODO add provider to get results of git --no-pager diff
+        // TODO add support to include multiple files
+        .option('-f, --file <file>', 'Input file. Content of this file will be added BEFORE the diff, but after requirements')
+        // TODO figure out what to do with this (we probably want to merge it with requirementsId)?
+        .option('-r, --requirements <requirements>', 'Requirements for this review.')
+        .addOption(
+            new Option('-p, --requirements-provider <requirementsProvider>', 'Requirements provider for this review.')
+                .choices(Object.keys(REQUIREMENTS_PROVIDERS))
+        )
+        .addOption(
+            new Option('--content-provider <contentProvider>', 'Content  provider')
+                .choices(Object.keys(CONTENT_PROVIDERS))
+        )
+        .option('-m, --message <message>', 'Extra message to provide just before the content')
+        .action(async (contentId, options) => {
+            const {initConfig} = await import("../config.js");
+            await initConfig();
+            const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
+            const content = [];
+            const requirementsId = options.requirements;
+            const requirementsProvider = options.requirementsProvider ?? context.config?.requirementsProvider;
+            const contentProvider = options.contentProvider ?? context.config?.contentProvider;
+
+            // TODO consider calling these in parallel
+            const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
+            if (requirements) {
+                content.push(requirements);
+            }
+
+            const providedContent = await getContentFromProvider(contentProvider, contentId);
+            if (providedContent) {
+                content.push(providedContent);
+            }
+
+            if (options.file) {
+                content.push(`${options.file}:\n\`\`\`\n${readFileFromCurrentDir(options.file)}\n\`\`\``);
+            }
+            if (context.stdin) {
+                content.push(context.stdin);
+            }
+            if (options.message) {
+                content.push(options.message);
+            }
+            const {review} = await import('../modules/reviewModule.js');
+            await review('sloth-DIFF-review', preamble.join("\n"), content.join("\n"));
+        });
+
+    program.command('pr')
+        .description('Review provided Pull Request in current directory. ' +
+            'This command is similar to `review`, but default content provider is `gh`. ' +
+            '(assuming that GH cli is installed and authenticated for current project')
+        .argument('<prId>', 'Pull request ID to review.')
+        .argument('[requirementsId]', 'Optional requirements ID argument to retrieve requirements with requirements provider')
+        .addOption(
+            new Option('-p, --requirements-provider <requirementsProvider>', 'Requirements provider for this review.')
+                .choices(Object.keys(REQUIREMENTS_PROVIDERS))
+        )
+        .option('-f, --file <file>', 'Input file. Content of this file will be added BEFORE the diff, but after requirements')
+        .action(async (prId, requirementsId, options) => {
+            const {initConfig} = await import("../config.js");
+            await initConfig();
+
+            const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
+            const content = [];
+            const requirementsProvider = options.requirementsProvider ?? context.config?.requirementsProvider;
+
+            // Handle requirements
+            const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
+            if (requirements) {
+                content.push(requirements);
+            }
+
+            if (options.file) {
+                content.push(`${options.file}:\n\`\`\`\n${readFileFromCurrentDir(options.file)}\n\`\`\``);
+            }
+
+            // Get PR diff using the 'gh' provider
+            const providerPath = `../providers/${CONTENT_PROVIDERS['gh']}`;
+            const {get} = await import(providerPath);
+            content.push(await get(null, prId));
+
+            const {review} = await import('../modules/reviewModule.js');
+            await review(`sloth-PR-${prId}-review`, preamble.join("\n"), content.join("\n"));
+        });
+
+    async function getRequirementsFromProvider(requirementsProvider, requirementsId) {
+        return getFromProvider(
+            requirementsProvider,
+            requirementsId,
+            (context.config?.requirementsProviderConfig ?? {})[requirementsProvider],
+            REQUIREMENTS_PROVIDERS
+        );
+    }
+
+    async function getContentFromProvider(contentProvider, contentId) {
+        return getFromProvider(
+            contentProvider,
+            contentId,
+            (context.config?.contentProviderConfig ?? {})[contentProvider],
+            CONTENT_PROVIDERS
+        )
+    }
+
+    async function getFromProvider(provider, id, config, legitPredefinedProviders) {
+        if (typeof provider === 'string') {
+            // Use one of the predefined providers
+            if (legitPredefinedProviders[provider]) {
+                const providerPath = `../providers/${legitPredefinedProviders[provider]}`;
+                const {get} = await import(providerPath);
+                return await get(config, id);
+            } else {
+                displayError(`Unknown provider: ${provider}. Continuing without it.`);
+            }
+        } else if (typeof provider === 'function') {
+            return await provider(id);
+        }
+        return '';
+    }
+}

package/src/config.js

@@ -27,7 +27,7 @@ export const slothContext = {
 };
 
 export async function initConfig() {
-    const configFileUrl = url.pathToFileURL(path.join(process.cwd(), USER_PROJECT_CONFIG_FILE));    
+    const configFileUrl = url.pathToFileURL(path.join(process.cwd(), USER_PROJECT_CONFIG_FILE));
     return import(configFileUrl)
         .then((i) => i.configure((module) => import(module)))    
         .then((config) => {

package/src/consoleUtils.js

@@ -1,5 +1,7 @@
 import chalk from 'chalk';
 
+// TODO it seems like commander supports coloured output, maybe dependency to chalk can be removed
+
 export function displayError (message) {
     console.error(chalk.red(message));
 }

package/src/{questionAnswering.js → modules/questionAnsweringModule.js}

@@ -1,68 +1,87 @@
-import {
-    END,
-    MemorySaver,
-    MessagesAnnotation,
-    START,
-    StateGraph,
-} from "@langchain/langgraph";
-import { writeFileSync } from "node:fs";
-import path from "node:path";
-import {initConfig, slothContext} from "./config.js";
-import { display, displayError, displaySuccess } from "./consoleUtils.js";
-import { fileSafeLocalDate, toFileSafeString } from "./utils.js";
-
-await initConfig();
-
-export async function askQuestion(source, preamble, content) {
-    // This node receives the current state (messages) and invokes the LLM
-    const callModel = async (state) => {
-        // state.messages will contain the list including the system preamble and user diff
-        const response = await slothContext.config.llm.invoke(state.messages);
-        // MessagesAnnotation expects the node to return the new message(s) to be added to the state.
-        // Wrap the response in an array if it's a single message object.
-        return { messages: response };
-    };
-
-    // Define the graph structure with MessagesAnnotation state
-    const workflow = new StateGraph(MessagesAnnotation)
-        // Define the node and edge
-        .addNode("model", callModel)
-        .addEdge(START, "model") // Start at the 'model' node
-        .addEdge("model", END); // End after the 'model' node completes
-
-    // Set up memory (optional but good practice for potential future multi-turn interactions)
-    const memory = new MemorySaver();
-
-    // Compile the workflow into a runnable app
-    const app = workflow.compile({ checkpointer: memory });
-
-    // Construct the initial the messages including the preamble as a system message
-    const messages = [
-        {
-            role: "system",
-            content: preamble, // The preamble goes here
-        },
-        {
-            role: "user",
-            content, // The code diff goes here
-        },
-    ];
-
-    display("Thinking...");
-    const output = await app.invoke({messages}, slothContext.session);
-    // FIXME this looks ugly, there should be other way
-    const outputContent = output.messages[output.messages.length - 1].content;
-    const filePath = path.resolve(process.cwd(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
-    display(`writing ${filePath}`);
-    // TODO highlight LLM output with something like Prism.JS
-    display(outputContent);
-    try {
-        writeFileSync(filePath, outputContent);
-        displaySuccess(`This report can be found in ${filePath}`);
-    } catch (error) {
-        displayError(`Failed to write review to file: ${filePath}`);
-        displayError(error.message);
-        // Consider if you want to exit or just log the error
-        // process.exit(1);
-    }
-}
+import {
+    END,
+    MemorySaver,
+    MessagesAnnotation,
+    START,
+    StateGraph,
+} from "@langchain/langgraph";
+import { writeFileSync } from "node:fs";
+import * as path from "node:path";
+import { slothContext } from "../config.js";
+import { display, displayError, displaySuccess } from "../consoleUtils.js";
+import { fileSafeLocalDate, toFileSafeString, ProgressIndicator, extractLastMessageContent } from "../utils.js";
+
+/**
+ * Ask a question and get an answer from the LLM
+ * @param {string} source - The source of the question (used for file naming)
+ * @param {string} preamble - The preamble to send to the LLM
+ * @param {string} content - The content of the question
+ */
+export async function askQuestion(source, preamble, content) {
+    const progressIndicator = new ProgressIndicator("Thinking.");
+    const outputContent = await askQuestionInner(slothContext, () => progressIndicator.indicate(), preamble, content);
+    const filePath = path.resolve(process.cwd(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
+    display(`\nwriting ${filePath}`);
+    // TODO highlight LLM output with something like Prism.JS
+    display('\n' + outputContent);
+    try {
+        writeFileSync(filePath, outputContent);
+        displaySuccess(`This report can be found in ${filePath}`);
+    } catch (error) {
+        displayError(`Failed to write answer to file: ${filePath}`);
+        displayError(error.message);
+        // Consider if you want to exit or just log the error
+        // process.exit(1);
+    }
+}
+
+/**
+ * Inner function to ask a question and get an answer from the LLM
+ * @param {Object} context - The context object
+ * @param {Function} indicateProgress - Function to indicate progress
+ * @param {string} preamble - The preamble to send to the LLM
+ * @param {string} content - The content of the question
+ * @returns {string} The answer from the LLM
+ */
+export async function askQuestionInner(context, indicateProgress, preamble, content) {
+    // This node receives the current state (messages) and invokes the LLM
+    const callModel = async (state) => {
+        // state.messages will contain the list including the system preamble and user diff
+        const response = await context.config.llm.invoke(state.messages);
+        // MessagesAnnotation expects the node to return the new message(s) to be added to the state.
+        // Wrap the response in an array if it's a single message object.
+        return { messages: response };
+    };
+
+    // Define the graph structure with MessagesAnnotation state
+    const workflow = new StateGraph(MessagesAnnotation)
+        // Define the node and edge
+        .addNode("model", callModel)
+        .addEdge(START, "model") // Start at the 'model' node
+        .addEdge("model", END); // End after the 'model' node completes
+
+    // Set up memory (optional but good practice for potential future multi-turn interactions)
+    const memory = new MemorySaver();
+
+    // Compile the workflow into a runnable app
+    const app = workflow.compile({ checkpointer: memory });
+
+    // Construct the initial the messages including the preamble as a system message
+    const messages = [
+        {
+            role: "system",
+            content: preamble, // The preamble goes here
+        },
+        {
+            role: "user",
+            content, // The question goes here
+        },
+    ];
+
+    indicateProgress();
+    // TODO create proper progress indicator for async tasks.
+    const progress = setInterval(() => indicateProgress(), 1000);
+    const output = await app.invoke({messages}, context.session);
+    clearInterval(progress);
+    return extractLastMessageContent(output);
+}

package/src/{codeReview.js → modules/reviewModule.js}

@@ -7,12 +7,11 @@ import {
 } from "@langchain/langgraph";
 import { writeFileSync } from "node:fs";
 import path from "node:path";
-import { initConfig, slothContext } from "./config.js";
-import { display, displayError, displaySuccess } from "./consoleUtils.js";
-import { fileSafeLocalDate, toFileSafeString, ProgressIndicator } from "./utils.js";
+import { initConfig, slothContext } from "../config.js";
+import { display, displayError, displaySuccess } from "../consoleUtils.js";
+import { fileSafeLocalDate, toFileSafeString, ProgressIndicator, extractLastMessageContent } from "../utils.js";
 
 export async function review(source, preamble, diff) {
-    await initConfig();
     const progressIndicator = new ProgressIndicator("Reviewing.");
     const outputContent = await reviewInner(slothContext, () => progressIndicator.indicate(), preamble, diff);
     const filePath = path.resolve(process.cwd(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
@@ -72,6 +71,5 @@ export async function reviewInner(context, indicateProgress, preamble, diff) {
     const progress = setInterval(() => indicateProgress(), 1000);
     const output = await app.invoke({messages}, context.session);
     clearInterval(progress);
-    // FIXME this looks ugly, there should be other way
-    return output.messages[output.messages.length - 1].content;
+    return extractLastMessageContent(output);
 }

package/src/providers/ghPrDiffProvider.js

@@ -0,0 +1,11 @@
+import {spawnCommand} from "../utils.js";
+import {displayWarning} from "../consoleUtils.js";
+
+export async function get(_, pr) {
+    // TODO makes sense to check if gh is available and authenticated
+    if (!pr) {
+        displayWarning("No PR provided, skipping PR diff fetching.")
+        return "";
+    }
+    return spawnCommand('gh', ['pr', 'diff', pr], 'Loading PR diff...', 'Loaded PR diff.');
+}

package/src/providers/jiraIssueLegacyAccessTokenProvider.js

@@ -0,0 +1,81 @@
+import {display, displayWarning} from "../consoleUtils.js";
+
+export async function get(config, prId) {
+    const issueData = await getJiraIssue(config, prId);
+    return `## ${prId} Requirements - ${issueData.fields?.summary}\n\n${issueData.fields?.description}`
+}
+
+/**
+ * Fetches a Jira issue using the Atlassian REST API v2.
+ *
+ * @async
+ * @param {object} config - Configuration object.
+ * @param {string} config.username - Your Jira email address or username used for authentication.
+ * @param {string} config.token - Your Jira API token (legacy access token).
+ * @param {string} config.baseUrl - The base URL of your Jira instance API (e.g., 'https://your-domain.atlassian.net/rest/api/2/issue/').
+ * @param {string} jiraKey - The Jira issue key (e.g., 'UI-1005').
+ * @returns {Promise<object>} A promise that resolves with the Jira issue data as a JSON object.
+ * @throws {Error} Throws an error if the fetch fails, authentication is wrong, the issue is not found, or the response status is not OK.
+ */
+async function getJiraIssue(config, jiraKey) {
+    const { username, token, baseUrl } = config;
+    if (!jiraKey) {
+        displayWarning("No jiraKey provided, skipping Jira issue fetching.")
+        return "";
+    }
+
+    // Validate essential inputs
+    if (!username || !token || !baseUrl) {
+        throw new Error('Missing required parameters in config (username, token, baseUrl) or missing jiraKey.');
+    }
+
+    // Ensure baseUrl doesn't end with a slash to avoid double slashes in the URL
+    const cleanBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+
+    // Construct the full API URL
+    const apiUrl = `${cleanBaseUrl}/${jiraKey}`;
+
+    // Encode credentials for Basic Authentication header
+    const credentials = `${username}:${token}`;
+    const encodedCredentials = Buffer.from(credentials).toString('base64');
+    const authHeader = `Basic ${encodedCredentials}`;
+
+    // Define request headers
+    const headers = {
+        'Authorization': authHeader,
+        'Accept': 'application/json', // Tell the server we expect JSON back
+        // 'Content-Type': 'application/json' // Usually not needed for GET requests
+    };
+
+    display(`Fetching Jira issue: ${apiUrl}`);
+
+    try {
+        const response = await fetch(apiUrl, {
+            method: 'GET',
+            headers: headers,
+        });
+
+        // Check if the response status code indicates success (e.g., 200 OK)
+        if (!response.ok) {
+            let errorBody = 'Could not read error body.';
+            try {
+                // Attempt to get more details from the response body for non-OK statuses
+                errorBody = await response.text();
+            } catch (e) {
+                // Silent fail - we already have a generic error message
+            }
+            // Throw a detailed error including status, status text, URL, and body if available
+            throw new Error(`HTTP error! Status: ${response.status} ${response.statusText}. URL: ${apiUrl}. Response Body: ${errorBody}`);
+        }
+
+        // Parse the JSON response body if the request was successful
+        const issueData = await response.json();
+        return issueData;
+
+    } catch (error) {
+        // Handle network errors (e.g., DNS resolution failure, connection refused)
+        // or errors thrown from the non-OK response check above
+        // Re-throw the error so the caller can handle it appropriately
+        throw error;
+    }
+}