gaunt-sloth-assistant 0.0.7 → 0.1.0

package/spec/questionAnsweringModule.spec.js

@@ -0,0 +1,137 @@
+import * as td from 'testdouble';
+
+describe('questionAnsweringModule', function (){
+
+    beforeEach(async function() {
+        // Reset testdouble before each test
+        td.reset();
+
+        // Create a mock context
+        this.mockLlmInvoke = td.function();
+        this.context = {
+            config: {
+                llm: {
+                    invoke: this.mockLlmInvoke
+                }
+            },
+            session: {configurable: {thread_id: 'test-thread-id'}}
+        };
+
+        // Create fs mock
+        this.fs = {
+            writeFileSync: td.function()
+        };
+
+        // Create path mock
+        this.path = {
+            resolve: td.function()
+        };
+
+        // Create consoleUtils mock
+        this.consoleUtils = {
+            display: td.function(),
+            displaySuccess: td.function(),
+            displayError: td.function()
+        };
+
+        // Create utils mock functions
+        const extractLastMessageContent = td.function();
+        const toFileSafeString = td.function();
+        const fileSafeLocalDate = td.function();
+        const ProgressIndicator = td.constructor();
+        const readFileSyncWithMessages = td.function();
+        const spawnCommand = td.function();
+
+        // Set up utils mock stubs
+        td.when(extractLastMessageContent(td.matchers.anything())).thenReturn('LLM Response');
+        td.when(toFileSafeString(td.matchers.anything())).thenReturn('sloth-ASK');
+        td.when(fileSafeLocalDate()).thenReturn('2025-01-01T00-00-00');
+
+        // Create the utils mock
+        this.utils = {
+            extractLastMessageContent,
+            toFileSafeString,
+            fileSafeLocalDate,
+            ProgressIndicator,
+            readFileSyncWithMessages,
+            spawnCommand
+        };
+
+        // Set up path.resolve mock
+        td.when(this.path.resolve(td.matchers.anything(), td.matchers.contains('sloth-ASK'))).thenReturn('test-file-path.md');
+
+        // Mock ProgressIndicator
+        this.progressIndicator = {
+            indicate: td.function()
+        };
+        td.when(new this.utils.ProgressIndicator(td.matchers.anything())).thenReturn(this.progressIndicator);
+
+        // Replace modules with mocks - do this after setting up all mocks
+        await td.replaceEsm("node:fs", this.fs);
+        await td.replaceEsm("node:path", this.path);
+        await td.replaceEsm("../src/consoleUtils.js", this.consoleUtils);
+        await td.replaceEsm("../src/utils.js", this.utils);
+
+        // Mock slothContext and other config exports
+        await td.replaceEsm("../src/config.js", {
+            slothContext: this.context,
+            SLOTH_INTERNAL_PREAMBLE: '.gsloth.preamble.internal.md',
+            USER_PROJECT_REVIEW_PREAMBLE: '.gsloth.preamble.review.md',
+            USER_PROJECT_CONFIG_FILE: '.gsloth.config.js',
+            initConfig: td.function()
+        });
+    });
+
+    it('Should call LLM with correct messages', async function() {
+        // Mock the LLM response
+        const llmResponse = [{ role: 'assistant', content: 'LLM Response' }];
+        td.when(this.mockLlmInvoke(td.matchers.anything())).thenResolve(llmResponse);
+
+        // Import the module after setting up mocks
+        const { askQuestionInner } = await import("../src/modules/questionAnsweringModule.js");
+
+        // Call the function
+        const result = await askQuestionInner(this.context, () => {}, 'Test Preamble', 'Test Content');
+
+        // Verify the result
+        expect(result).toBe('LLM Response');
+    });
+
+    it('Should write output to file', async function() {
+        // Mock the LLM response
+        const llmResponse = [{ role: 'assistant', content: 'LLM Response' }];
+        td.when(this.mockLlmInvoke(td.matchers.anything())).thenResolve(llmResponse);
+
+        // Import the module after setting up mocks
+        const { askQuestion } = await import("../src/modules/questionAnsweringModule.js");
+
+        // Call the function and wait for it to complete
+        await askQuestion('sloth-ASK', 'Test Preamble', 'Test Content');
+
+        // Verify the file was written with the correct content
+        td.verify(this.fs.writeFileSync('test-file-path.md', 'LLM Response'));
+
+        // Verify success message was displayed
+        td.verify(this.consoleUtils.displaySuccess(td.matchers.contains('test-file-path.md')));
+    });
+
+    it('Should handle file write errors', async function() {
+        // Mock the LLM response
+        const llmResponse = [{ role: 'assistant', content: 'LLM Response' }];
+        td.when(this.mockLlmInvoke(td.matchers.anything())).thenResolve(llmResponse);
+
+        // Mock file write to throw an error
+        const error = new Error('File write error');
+        td.when(this.fs.writeFileSync('test-file-path.md', 'LLM Response')).thenThrow(error);
+
+        // Import the module after setting up mocks
+        const { askQuestion } = await import("../src/modules/questionAnsweringModule.js");
+
+        // Call the function and wait for it to complete
+        await askQuestion('sloth-ASK', 'Test Preamble', 'Test Content');
+
+        // Verify error message was displayed
+        td.verify(this.consoleUtils.displayError(td.matchers.contains('test-file-path.md')));
+        td.verify(this.consoleUtils.displayError('File write error'));
+    });
+});

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/reviewModule.spec.js

@@ -0,0 +1,22 @@
+import { reviewInner } from '../src/modules/reviewModule.js';
+import { slothContext } from '../src/config.js';
+import { FakeListChatModel } from "@langchain/core/utils/testing";
+
+describe('reviewModule', () => {
+
+  it('should invoke LLM', async () => {
+    // Setup mock for slothContext
+    const testContext = {...slothContext, 
+      config: {
+        llm: new FakeListChatModel({
+          responses: ["First LLM message", "Second LLM message"],
+        })
+      }
+    };
+
+    // Test the function
+    const output = await reviewInner(testContext, () => {}, 'test-preamble', 'test-diff');
+    expect(output).toBe("First LLM message");
+  });
+
+});

package/spec/support/jasmine.mjs

@@ -0,0 +1,14 @@
+export default {
+  spec_dir: "spec",
+  spec_files: [
+    "**/*[sS]pec.?(m)js"
+  ],
+  helpers: [
+    "helpers/**/*.?(m)js"
+  ],
+  env: {
+    stopSpecOnExpectationFailure: false,
+    random: true,
+    forbidDuplicateNames: true
+  }
+}

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(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

@@ -1,16 +1,14 @@
-import path, {dirname} from "node:path";
+import path from "node:path";
 import url from "node:url";
-import {v4 as uuidv4} from "uuid";
-import {display, displayError, displayInfo, displaySuccess, displayWarning} from "./consoleUtils.js";
-import {fileURLToPath} from "url";
-import {write, writeFileSync, existsSync} from "node:fs";
-import {writeFileIfNotExistsWithMessages} from "./utils.js";
+import { v4 as uuidv4 } from "uuid";
+import { displayError, displayInfo, displayWarning } from "./consoleUtils.js";
+import { writeFileIfNotExistsWithMessages } from "./utils.js";
 
 export const USER_PROJECT_CONFIG_FILE = '.gsloth.config.js'
 export const SLOTH_INTERNAL_PREAMBLE = '.gsloth.preamble.internal.md';
 export const USER_PROJECT_REVIEW_PREAMBLE = '.gsloth.preamble.review.md';
 
-export const availableDefaultConfigs = ['vertexai', 'anthropic'];
+export const availableDefaultConfigs = ['vertexai', 'anthropic', 'groq'];
 
 export const slothContext = {
     /**
@@ -30,9 +28,16 @@ export const slothContext = {
 
 export async function initConfig() {
     const configFileUrl = url.pathToFileURL(path.join(process.cwd(), USER_PROJECT_CONFIG_FILE));
-    const {configure} = await import(configFileUrl);
-    const config = await configure((module) => import(module));
-    slothContext.config = {...config};
+    return import(configFileUrl)
+        .then((i) => i.configure((module) => import(module)))    
+        .then((config) => {
+            slothContext.config = {...config};
+        })
+        .catch((e) => {
+            console.log(e);
+            displayError(`Failed to read config, make sure ${configFileUrl} contains valid JavaScript.`);
+            process.exit();
+        });    
 }
 
 export async function createProjectConfig(configType) {

package/src/configs/anthropic.js

@@ -11,7 +11,7 @@ export async function configure(importFunction, global) {
     const anthropic = await importFunction('@langchain/anthropic');
     return {
         llm: new anthropic.ChatAnthropic({
-            apiKey: "sk-ant-api--YOUR_API_HASH", // You should put your API hash here
+            apiKey: process.env.ANTHROPIC_API_KEY, // Default value, but you can provide the key in many different ways, even as literal
             model: "claude-3-5-sonnet-20241022" // Don't forget to check new models availability.
         })
     };

package/src/configs/groq.js

@@ -0,0 +1,25 @@
+import {writeFileIfNotExistsWithMessages} from "../utils.js";
+import path from "node:path";
+import {displayInfo, displayWarning} from "../consoleUtils.js";
+import {USER_PROJECT_CONFIG_FILE} from "../config.js";
+
+const content = `/* 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
+    const groq = await importFunction('@langchain/groq');
+    return {
+        llm: new groq.ChatGroq({
+            model: "deepseek-r1-distill-llama-70b", // Check other models available
+            apiKey: process.env.GROQ_API_KEY, // Default value, but you can provide the key in many different ways, even as literal
+        })
+    };
+}
+`;
+
+export function init(configFileName, context) {
+    path.join(context.currentDir, configFileName);
+    writeFileIfNotExistsWithMessages(configFileName, content);
+    displayInfo(`You can define GROQ_API_KEY environment variable with your Groq API key and it will work with default model.`);
+    displayWarning(`You need to edit your ${USER_PROJECT_CONFIG_FILE} to to configure model.`);
+}

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