gaunt-sloth-assistant 0.1.2 → 0.1.4

package/src/configs/vertexai.js

@@ -2,7 +2,7 @@ import {writeFileIfNotExistsWithMessages} from "../utils.js";
 import path from "node:path";
 import {displayWarning} from "../consoleUtils.js";
 
-const content = `/* eslint-disable */
+const jsContent = `/* eslint-disable */
 export async function configure(importFunction, global) {
     // this is going to be imported from sloth dependencies,
     // but can potentially be pulled from global node modules or from this project
@@ -19,8 +19,29 @@ export async function configure(importFunction, global) {
 }
 `;
 
+const jsonContent = `{
+  "llm": {
+    "type": "vertexai",
+    "model": "gemini-2.5-pro-exp-03-25",
+    "temperature": 0
+  }
+}`;
+
 export function init(configFileName, context) {
     path.join(context.currentDir, configFileName);
+
+    // Determine which content to use based on file extension
+    const content = configFileName.endsWith('.json') ? jsonContent : jsContent;
+
     writeFileIfNotExistsWithMessages(configFileName, content);
     displayWarning("For Google VertexAI you likely to need to do `gcloud auth login` and `gcloud auth application-default login`.");
-}
+}
+
+// Function to process JSON config and create VertexAI LLM instance
+export async function processJsonConfig(llmConfig) {
+    const vertexAi = await import('@langchain/google-vertexai');
+    return new vertexAi.ChatVertexAI({
+        ...llmConfig,
+        model: llmConfig.model || "gemini-pro"
+    });
+}

package/src/consoleUtils.js

@@ -1,23 +1,33 @@
 import chalk from 'chalk';
+import {debug as systemDebug, error as systemError, log} from './systemUtils.js';
 
 // TODO it seems like commander supports coloured output, maybe dependency to chalk can be removed
 
 export function displayError (message) {
-    console.error(chalk.red(message));
+    systemError(chalk.red(message));
 }
 
 export function displayWarning (message) {
-    console.error(chalk.yellow(message));
+    systemError(chalk.yellow(message));
 }
 
 export function displaySuccess (message) {
-    console.error(chalk.green(message));
+    systemError(chalk.green(message));
 }
 
 export function displayInfo (message) {
-    console.error(chalk.blue(message));
+    systemError(chalk.blue(message));
 }
 
 export function display(message) {
-    console.log(message);
+    log(message);
+}
+
+export function displayDebug(message) {
+    // TODO make it controlled by config
+    if (message?.stack) {
+        systemDebug(message.stack);
+    } else {
+        systemDebug(message);
+    }
 }

package/src/modules/questionAnsweringModule.js

@@ -1,15 +1,10 @@
-import {
-    END,
-    MemorySaver,
-    MessagesAnnotation,
-    START,
-    StateGraph,
-} from "@langchain/langgraph";
-import { writeFileSync } from "node:fs";
+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";
+import {slothContext} from "../config.js";
+import {display, displayError, displaySuccess} from "../consoleUtils.js";
+import {extractLastMessageContent, fileSafeLocalDate, ProgressIndicator, toFileSafeString} from "../utils.js";
+import {getCurrentDir} from "../systemUtils.js";
 
 /**
  * Ask a question and get an answer from the LLM
@@ -20,7 +15,7 @@ import { fileSafeLocalDate, toFileSafeString, ProgressIndicator, extractLastMess
 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");
+    const filePath = path.resolve(getCurrentDir(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
     display(`\nwriting ${filePath}`);
     // TODO highlight LLM output with something like Prism.JS
     display('\n' + outputContent);
@@ -30,8 +25,8 @@ export async function askQuestion(source, preamble, content) {
     } 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);
+        // TODO Consider if we want to exit or just log the error
+        // exit(1);
     }
 }
 

package/src/modules/reviewModule.js

@@ -1,33 +1,28 @@
-import {
-    END,
-    MemorySaver,
-    MessagesAnnotation,
-    START,
-    StateGraph,
-} from "@langchain/langgraph";
-import { writeFileSync } from "node:fs";
+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, ProgressIndicator, extractLastMessageContent } from "../utils.js";
+import {slothContext} from "../config.js";
+import {display, displayDebug, displayError, displaySuccess} from "../consoleUtils.js";
+import {extractLastMessageContent, fileSafeLocalDate, ProgressIndicator, toFileSafeString} from "../utils.js";
+import {getCurrentDir, stdout} from "../systemUtils.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");
+    const filePath = path.resolve(getCurrentDir(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
+    stdout.write("\n");
     display(`writing ${filePath}`);
-    process.stdout.write("\n");
+    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) {
+        displayDebug(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);
+        // exit(1);
     }
 }
 

package/src/prompt.js

@@ -2,10 +2,11 @@ import {resolve} from "node:path";
 import {SLOTH_INTERNAL_PREAMBLE, slothContext} from "./config.js";
 import {readFileSyncWithMessages, spawnCommand} from "./utils.js";
 import { displayError } from "./consoleUtils.js";
+import { exit } from "./systemUtils.js";
 
 export function readInternalPreamble() {
     const filePath = resolve(slothContext.installDir, SLOTH_INTERNAL_PREAMBLE);
-    return readFileSyncWithMessages(filePath, "Error reading internal preamble file at:")
+    return readFileSyncWithMessages(filePath, "Error reading internal preamble file at:");
 }
 
 export function readPreamble(preambleFilename) {
@@ -14,7 +15,7 @@ export function readPreamble(preambleFilename) {
         filePath,
         "Error reading preamble file at:",
         "Consider running `gsloth init` to set up your project. Check `gsloth init --help` to see options."
-    )
+    );
 }
 
 /**
@@ -28,6 +29,6 @@ export async function getPrDiff(pr) {
     } catch (e) {
         displayError(e.toString());
         displayError(`Failed to call "gh pr diff ${pr}", see message above for details.`);
-        process.exit();
+        exit();
     }
 }

package/src/providers/file.js

@@ -0,0 +1,19 @@
+import {resolve} from "node:path";
+import {slothContext} from "../config.js";
+import {display} from "../consoleUtils.js";
+import {readFileSyncWithMessages} from "../utils.js";
+
+/**
+ * Reads the text file from current dir
+ * @param _ config (unused in this provider)
+ * @param fileName
+ * @returns {string} file contents
+ */
+export function get(_, fileName) {
+    if (!fileName) {
+        return null;
+    }
+    const filePath = resolve(slothContext.currentDir, fileName);
+    display(`Reading file ${fileName}...`);
+    return readFileSyncWithMessages(filePath);
+}

package/src/providers/ghPrDiffProvider.js

@@ -4,8 +4,8 @@ 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.")
+        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

@@ -1,8 +1,9 @@
 import {display, displayWarning} from "../consoleUtils.js";
+import { env } from "../systemUtils.js";
 
 export async function get(config, prId) {
     const issueData = await getJiraIssue(config, prId);
-    return `## ${prId} Requirements - ${issueData.fields?.summary}\n\n${issueData.fields?.description}`
+    return `## ${prId} Requirements - ${issueData.fields?.summary}\n\n${issueData.fields?.description}`;
 }
 
 /**
@@ -18,15 +19,23 @@ export async function get(config, prId) {
  * @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;
+    const {username, baseUrl} = config;
     if (!jiraKey) {
-        displayWarning("No jiraKey provided, skipping Jira issue fetching.")
+        displayWarning("No jiraKey provided, skipping Jira issue fetching.");
         return "";
     }
+    const token = env.JIRA_LEGACY_API_TOKEN ?? config?.token;
+
+    if (!token) {
+        throw new Error(
+            'Missing JIRA Legacy API token. ' +
+            'The legacy token can be defined as JIRA_LEGACY_API_TOKEN environment variable or as "token" in config.'
+        );
+    }
 
     // Validate essential inputs
-    if (!username || !token || !baseUrl) {
-        throw new Error('Missing required parameters in config (username, token, baseUrl) or missing jiraKey.');
+    if (!username || !baseUrl) {
+        throw new Error('Missing required parameters in config: username or baseUrl');
     }
 
     // Ensure baseUrl doesn't end with a slash to avoid double slashes in the URL
@@ -49,33 +58,27 @@ async function getJiraIssue(config, jiraKey) {
 
     display(`Fetching Jira issue: ${apiUrl}`);
 
-    try {
-        const response = await fetch(apiUrl, {
-            method: 'GET',
-            headers: headers,
-        });
+    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}`);
+    // 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();
+            // eslint-disable-next-line no-unused-vars
+        } 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;
+    // 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

@@ -3,4 +3,4 @@
  */
 export async function get(_, text) {
     return text;
-}
+}

package/src/systemUtils.js

@@ -0,0 +1,32 @@
+/**
+ * This file contains all system functions and objects that are globally available
+ * but not imported directly, such as process.stdin, process.stdout, process.argv,
+ * process.env, process.cwd(), process.exit(), etc.
+ *
+ * By centralizing these in one file, we improve testability and make it easier
+ * to mock these dependencies in tests.
+ */
+
+const innerState = {
+    installDir: undefined
+};
+
+/* eslint-disable no-undef */
+// Process-related functions and objects
+export const getCurrentDir = () => process.cwd();
+export const getInstallDir = () => innerState.installDir;
+export const exit = (code) => process.exit(code);
+export const stdin = process.stdin;
+export const stdout = process.stdout;
+export const argv = process.argv;
+export const env = process.env;
+
+export const setInstallDir = (dir) => innerState.installDir = dir;
+
+// Console-related functions
+export const log = (message) => console.log(message);
+export const error = (message) => console.error(message);
+export const warn = (message) => console.warn(message);
+export const info = (message) => console.info(message);
+export const debug = (message) => console.debug(message);
+/* eslint-enable no-undef */

package/src/utils.js

@@ -3,6 +3,8 @@ import {existsSync, readFileSync, writeFileSync} from "node:fs";
 import {slothContext} from "./config.js";
 import {resolve} from "node:path";
 import {spawn} from "node:child_process";
+import {exit, stdin, stdout, argv} from "./systemUtils.js";
+import url from "node:url";
 
 export function toFileSafeString(string) {
     return string.replace(/[^A-Za-z0-9]/g, '-');
@@ -45,27 +47,28 @@ export function readFileSyncWithMessages(filePath, errorMessageIn, noFileMessage
         } else {
             displayError(error.message);
         }
-        process.exit(1); // Exit gracefully after error
+        exit(1); // Exit gracefully after error
     }
 }
 
 export function readStdin(program) {
     return new Promise((resolve) => {
-        if(process.stdin.isTTY) {
+        // TODO use progress indicator here
+        if(stdin.isTTY) {
             program.parseAsync().then(resolve);
         } else {
             // Support piping diff into gsloth
-            process.stdout.write('reading STDIN.');
-            process.stdin.on('readable', function() {
+            stdout.write('reading STDIN.');
+            stdin.on('readable', function() {
                 const chunk = this.read();
-                process.stdout.write('.');
+                stdout.write('.');
                 if (chunk !== null) {
                     slothContext.stdin += chunk;
                 }
             });
-            process.stdin.on('end', function() {
-                process.stdout.write('.\n');
-                program.parseAsync(process.argv).then(resolve);
+            stdin.on('end', function() {
+                stdout.write('.\n');
+                program.parseAsync(argv).then(resolve);
             });
         }
     });
@@ -76,17 +79,17 @@ export async function spawnCommand(command, args, progressMessage, successMessag
         // TODO use progress indicator
         const out = {stdout: '', stderr: ''};
         const spawned = spawn(command, args);
-        spawned.stdout.on('data', async (stdoutChunk, dd) => {
+        spawned.stdout.on('data', async (stdoutChunk) => {
             display(progressMessage);
             out.stdout += stdoutChunk.toString();
         });
         spawned.stderr.on('data', (err) => {
             display(progressMessage);
             out.stderr += err.toString();
-        })
+        });
         spawned.on('error', (err) => {
             reject(err.toString());
-        })
+        });
         spawned.on('close', (code) => {
             if (code === 0) {
                 display(successMessage);
@@ -115,10 +118,10 @@ export class ProgressIndicator {
 
     indicate() {
         if (this.hasBeenCalled) {
-            process.stdout.write('.');
+            stdout.write('.');
         } else {
             this.hasBeenCalled = true;
-            process.stdout.write(this.initialMessage);
+            stdout.write(this.initialMessage);
         }
     }
 
@@ -135,3 +138,36 @@ export function extractLastMessageContent(output) {
     }
     return output.messages[output.messages.length - 1].content;
 }
+
+/**
+ * Dynamically imports a module from a file path from the outside of the installation dir
+ * @param {string} filePath - The path to the file to import
+ * @returns {Promise} A promise that resolves to the imported module
+ */
+export function importExternalFile(filePath) {
+    const configFileUrl = url.pathToFileURL(filePath);
+    return import(configFileUrl);
+}
+
+/**
+ * Alias for importExternalFile for backward compatibility with tests
+ * @param {string} filePath - The path to the file to import
+ * @returns {Promise} A promise that resolves to the imported module
+ */
+export const importFromFilePath = importExternalFile;
+
+/**
+ * Reads multiple files from the current directory and returns their contents
+ * @param {string[]} fileNames - Array of file names to read
+ * @returns {string} Combined content of all files with proper formatting
+ */
+export function readMultipleFilesFromCurrentDir(fileNames) {
+    if (!Array.isArray(fileNames)) {
+        return readFileFromCurrentDir(fileNames);
+    }
+    
+    return fileNames.map(fileName => {
+        const content = readFileFromCurrentDir(fileName);
+        return `${fileName}:\n\`\`\`\n${content}\n\`\`\``;
+    }).join('\n\n');
+}