gaunt-sloth-assistant 0.1.5 → 0.3.0

package/src/config.js

@@ -1,177 +0,0 @@
-import path from "node:path/posix";
-import {v4 as uuidv4} from "uuid";
-import {displayDebug, displayError, displayInfo, displayWarning} from "./consoleUtils.js";
-import {importExternalFile, writeFileIfNotExistsWithMessages} from "./utils.js";
-import {existsSync, readFileSync} from "node:fs";
-import {exit, getCurrentDir} from "./systemUtils.js";
-
-export const USER_PROJECT_CONFIG_JS = '.gsloth.config.js';
-export const USER_PROJECT_CONFIG_JSON = '.gsloth.config.json';
-export const USER_PROJECT_CONFIG_MJS = '.gsloth.config.mjs';
-export const SLOTH_INTERNAL_PREAMBLE = '.gsloth.preamble.internal.md';
-export const USER_PROJECT_REVIEW_PREAMBLE = '.gsloth.preamble.review.md';
-
-export const availableDefaultConfigs = ['vertexai', 'anthropic', 'groq'];
-
-export const DEFAULT_CONFIG = {
-    llm: undefined,
-    contentProvider: "file",
-    requirementsProvider: "file",
-    commands: {
-        pr: {
-            contentProvider: "gh"
-        }
-    }
-};
-
-export const slothContext = {
-    /**
-     * Directory where the sloth is installed.
-     * index.js should set up this.
-     */
-    installDir: null,
-    /**
-     * Directory where the sloth has been invoked. Usually user's project root.
-     * index.js should set up this.
-     */
-    currentDir: null,
-    config: DEFAULT_CONFIG,
-    stdin: '',
-    session: {configurable: {thread_id: uuidv4()}}
-};
-
-export async function initConfig() {
-    const currentDir = getCurrentDir();
-    const jsonConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_JSON);
-    const jsConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_JS);
-    const mjsConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_MJS);
-
-    // Try loading JSON config file first
-    if (existsSync(jsonConfigPath)) {
-        try {
-            const jsonConfig = JSON.parse(readFileSync(jsonConfigPath, 'utf8'));
-
-            // If the config has an LLM with a type, create the appropriate LLM instance
-            if (jsonConfig.llm && jsonConfig.llm.type) {
-                await tryJsonConfig(jsonConfig);
-            } else {
-                slothContext.config = {...slothContext.config, ...jsonConfig};
-            }
-        } catch (e) {
-            displayDebug(e);
-            displayError(`Failed to read config from ${USER_PROJECT_CONFIG_JSON}, will try other formats.`);
-            // Continue to try other formats
-            return tryJsConfig();
-        }
-    } else {
-        // JSON config not found, try JS
-        return tryJsConfig();
-    }
-
-    // Helper function to try loading JS config
-    async function tryJsConfig() {
-        if (existsSync(jsConfigPath)) {
-            return importExternalFile(jsConfigPath)
-                .then((i) => i.configure((module) => import(module)))
-                .then((config) => {
-                    slothContext.config = {...slothContext.config, ...config};
-                })
-                .catch((e) => {
-                    displayDebug(e);
-                    displayError(`Failed to read config from ${USER_PROJECT_CONFIG_JS}, will try other formats.`);
-                    // Continue to try other formats
-                    return tryMjsConfig();
-                });
-        } else {
-            // JS config not found, try MJS
-            return tryMjsConfig();
-        }
-    }
-
-    // Helper function to try loading MJS config
-    async function tryMjsConfig() {
-        if (existsSync(mjsConfigPath)) {
-            return importExternalFile(mjsConfigPath)
-                .then((i) => i.configure((module) => import(module)))
-                .then((config) => {
-                    slothContext.config = {...slothContext.config, ...config};
-                })
-                .catch((e) => {
-                    displayDebug(e);
-                    displayError(`Failed to read config from ${USER_PROJECT_CONFIG_MJS}.`);
-                    displayError(`No valid configuration found. Please create a valid configuration file.`);
-                    exit();
-                });
-        } else {
-            // No config files found
-            displayError(
-                'No configuration file found. Please create one of: '
-                + `${USER_PROJECT_CONFIG_JSON}, ${USER_PROJECT_CONFIG_JS}, or ${USER_PROJECT_CONFIG_MJS} `
-                + 'in your project directory.'
-            );
-            exit();
-        }
-    }
-}
-
-// Process JSON LLM config by creating the appropriate LLM instance
-export async function tryJsonConfig(jsonConfig) {
-    const llmConfig = jsonConfig.llm;
-    const llmType = llmConfig.type.toLowerCase();
-
-    // Check if the LLM type is in availableDefaultConfigs
-    if (!availableDefaultConfigs.includes(llmType)) {
-        displayError(`Unsupported LLM type: ${llmType}. Available types are: ${availableDefaultConfigs.join(', ')}`);
-        slothContext.config = {...slothContext.config, ...jsonConfig};
-        return;
-    }
-
-    try {
-        // Import the appropriate config module based on the LLM type
-        try {
-            const configModule = await import(`./configs/${llmType}.js`);
-            if (configModule.processJsonConfig) {
-                jsonConfig.llm = await configModule.processJsonConfig(llmConfig);
-            } else {
-                displayWarning(`Config module for ${llmType} does not have processJsonConfig function.`);
-            }
-        } catch (importError) {
-            displayDebug(importError);
-            displayWarning(`Could not import config module for ${llmType}.`);
-        }
-    } catch (error) {
-        displayDebug(error);
-        displayError(`Error creating LLM instance for type ${llmType}.`);
-    }
-
-    slothContext.config = {...slothContext.config, ...jsonConfig};
-}
-
-export async function createProjectConfig(configType) {
-    displayInfo(`Setting up your project\n`);
-    writeProjectReviewPreamble();
-    displayWarning(`Make sure you add as much detail as possible to your ${USER_PROJECT_REVIEW_PREAMBLE}.\n`);
-
-    // Check if the config type is in availableDefaultConfigs
-    if (!availableDefaultConfigs.includes(configType)) {
-        displayError(`Unsupported config type: ${configType}. Available types are: ${availableDefaultConfigs.join(', ')}`);
-        exit(1);
-        return;
-    }
-
-    displayInfo(`Creating project config for ${configType}`);
-    const vendorConfig = await import(`./configs/${configType}.js`);
-    vendorConfig.init(USER_PROJECT_CONFIG_JSON, slothContext);
-}
-
-export function writeProjectReviewPreamble() {
-    let reviewPreamblePath = path.join(slothContext.currentDir, USER_PROJECT_REVIEW_PREAMBLE);
-    writeFileIfNotExistsWithMessages(
-        reviewPreamblePath,
-        'You are doing generic code review.\n'
-        + ' Important! Please remind user to prepare proper AI preamble in'
-        + USER_PROJECT_REVIEW_PREAMBLE
-        + ' for this project. Use decent amount of ⚠️ to highlight lack of config.'
-        + ' Explicitly mention `' + USER_PROJECT_REVIEW_PREAMBLE + '`.'
-    );
-}

package/src/modules/questionAnsweringModule.js

@@ -1,82 +0,0 @@
-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 {extractLastMessageContent, fileSafeLocalDate, ProgressIndicator, toFileSafeString} from "../utils.js";
-import {getCurrentDir} from "../systemUtils.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(getCurrentDir(), 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);
-        // TODO Consider if we want to exit or just log the error
-        // 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/modules/reviewModule.js

@@ -1,70 +0,0 @@
-import {END, MemorySaver, MessagesAnnotation, START, StateGraph,} from "@langchain/langgraph";
-import {writeFileSync} from "node:fs";
-import path from "node:path";
-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(getCurrentDir(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
-    stdout.write("\n");
-    display(`writing ${filePath}`);
-    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}`);
-        // Consider if you want to exit or just log the error
-        // 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 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(); // TODO extract to config
-
-    // 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: diff, // The code diff 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/prompt.js

@@ -1,34 +0,0 @@
-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:");
-}
-
-export function readPreamble(preambleFilename) {
-    const filePath = resolve(slothContext.currentDir, preambleFilename);
-    return readFileSyncWithMessages(
-        filePath,
-        "Error reading preamble file at:",
-        "Consider running `gsloth init` to set up your project. Check `gsloth init --help` to see options."
-    );
-}
-
-/**
- * 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
-    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.`);
-        exit();
-    }
-}

package/src/providers/file.js

@@ -1,19 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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}`;
-}
-
-/**
- * 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, baseUrl} = config;
-    if (!jiraKey) {
-        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 || !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
-    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}`);
-
-    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();
-            // 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;
-
-}

package/src/providers/text.js

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

package/src/systemUtils.js

@@ -1,32 +0,0 @@
-/**
- * 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 */