gaunt-sloth-assistant 0.0.7 → 0.1.0

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,17 +7,35 @@ 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 } from "./utils.js";
-
-await initConfig();
+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) {
+    const progressIndicator = new ProgressIndicator("Reviewing.");
+    const outputContent = await reviewInner(slothContext, () => progressIndicator.indicate(), preamble, diff);
+    const filePath = path.resolve(process.cwd(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
+    process.stdout.write("\n");
+    display(`writing ${filePath}`);
+    process.stdout.write("\n");
+    // TODO highlight LLM output with something like Prism.JS (maybe system emoj are enough ✅⚠️❌)
+    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);
+    }
+}
+
+export async function reviewInner(context, indicateProgress, preamble, diff) {
     // 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);
+        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 };
@@ -48,26 +66,10 @@ export async function review(source, preamble, diff) {
         },
     ];
 
-    process.stdout.write("Reviewing.");
+    indicateProgress();
     // TODO create proper progress indicator for async tasks.
-    const progress = setInterval(() => process.stdout.write('.'), 1000);
-    const output = await app.invoke({messages}, slothContext.session);
-    const filePath = path.resolve(process.cwd(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
-    process.stdout.write("\n");
-    display(`writing ${filePath}`);
-    // FIXME this looks ugly, there should be other way
-    const outputContent = output.messages[output.messages.length - 1].content;
+    const progress = setInterval(() => indicateProgress(), 1000);
+    const output = await app.invoke({messages}, context.session);
     clearInterval(progress);
-    process.stdout.write("\n");
-    // TODO highlight LLM output with something like Prism.JS (maybe system emoj are enough ✅⚠️❌)
-    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);
-    }
+    return extractLastMessageContent(output);
 }

package/src/prompt.js

@@ -1,6 +1,7 @@
 import {resolve} from "node:path";
 import {SLOTH_INTERNAL_PREAMBLE, slothContext} from "./config.js";
 import {readFileSyncWithMessages, spawnCommand} from "./utils.js";
+import { displayError } from "./consoleUtils.js";
 
 export function readInternalPreamble() {
     const filePath = resolve(slothContext.installDir, SLOTH_INTERNAL_PREAMBLE);
@@ -18,8 +19,15 @@ export function readPreamble(preambleFilename) {
 
 /**
  * This function expects https://cli.github.com/ to be installed and authenticated.
+ * It does something like `gh pr diff 42`
  */
 export async function getPrDiff(pr) {
     // TODO makes sense to check if gh is available and authenticated
-    return spawnCommand('gh', ['pr', 'diff', pr], 'Loading PR diff...', 'Loaded PR diff.');
+    try {
+        return await spawnCommand('gh', ['pr', 'diff', pr], 'Loading PR diff...', 'Loaded PR diff.');
+    } catch (e) {
+        displayError(e.toString());
+        displayError(`Failed to call "gh pr diff ${pr}", see message above for details.`);
+        process.exit();
+    }
 }

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;
+    }
+}

package/src/providers/text.js

@@ -0,0 +1,6 @@
+/**
+ * Simple provider returning text as it is.
+ */
+export async function get(_, text) {
+    return text;
+}

package/src/utils.js

@@ -50,39 +50,51 @@ export function readFileSyncWithMessages(filePath, errorMessageIn, noFileMessage
 }
 
 export function readStdin(program) {
-    if(process.stdin.isTTY) {
-        program.parse();
-    } else {
-        // Support piping diff into gsloth
-        process.stdout.write('reading STDIN.');
-        process.stdin.on('readable', function() {
-            const chunk = this.read();
-            process.stdout.write('.');
-            if (chunk !== null) {
-                slothContext.stdin += chunk;
-            }
-        });
-        process.stdin.on('end', function() {
-            process.stdout.write('.\n');
-            program.parse(process.argv);
-        });
-    }
+    return new Promise((resolve) => {
+        if(process.stdin.isTTY) {
+            program.parseAsync().then(resolve);
+        } else {
+            // Support piping diff into gsloth
+            process.stdout.write('reading STDIN.');
+            process.stdin.on('readable', function() {
+                const chunk = this.read();
+                process.stdout.write('.');
+                if (chunk !== null) {
+                    slothContext.stdin += chunk;
+                }
+            });
+            process.stdin.on('end', function() {
+                process.stdout.write('.\n');
+                program.parseAsync(process.argv).then(resolve);
+            });
+        }
+    });
 }
 
 export async function spawnCommand(command, args, progressMessage, successMessage) {
     return new Promise((resolve, reject) => {
-        const out = {stdout: ''};
+        // TODO use progress indicator
+        const out = {stdout: '', stderr: ''};
         const spawned = spawn(command, args);
-        spawned.stdout.on('data', async (stdoutChunk) => {
+        spawned.stdout.on('data', async (stdoutChunk, dd) => {
             display(progressMessage);
             out.stdout += stdoutChunk.toString();
         });
+        spawned.stderr.on('data', (err) => {
+            display(progressMessage);
+            out.stderr += err.toString();
+        })
         spawned.on('error', (err) => {
-            reject(err);
+            reject(err.toString());
         })
         spawned.on('close', (code) => {
-            display(successMessage);
-            resolve(out.stdout);
+            if (code === 0) {
+                display(successMessage);
+                resolve(out.stdout);
+            } else {
+                displayError(`Failed to spawn command with code ${code}`);
+                reject(out.stdout + ' ' + out.stderr);
+            }
         });
     });
 }
@@ -92,3 +104,34 @@ export function getSlothVersion() {
     const projectJson = readFileSync(jsonPath, { encoding: 'utf8' });
     return JSON.parse(projectJson).version;
 }
+
+
+export class ProgressIndicator {
+
+    constructor(initialMessage) {
+        this.hasBeenCalled = false;
+        this.initialMessage = initialMessage;
+    }
+
+    indicate() {
+        if (this.hasBeenCalled) {
+            process.stdout.write('.');
+        } else {
+            this.hasBeenCalled = true;
+            process.stdout.write(this.initialMessage);
+        }
+    }
+
+}
+
+/**
+ * Extracts the content of the last message from an LLM response
+ * @param {Object} output - The output from the LLM containing messages
+ * @returns {string} The content of the last message
+ */
+export function extractLastMessageContent(output) {
+    if (!output || !output.messages || !output.messages.length) {
+        return '';
+    }
+    return output.messages[output.messages.length - 1].content;
+}