gaunt-sloth-assistant 0.1.5 → 0.2.2

package/spec/questionAnsweringModule.spec.js

@@ -1,137 +0,0 @@
-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.fsMock = {
-            writeFileSync: td.function()
-        };
-
-        // Create path mock
-        this.path = {
-            resolve: td.function(),
-            dirname: td.function()
-        };
-
-        // Create consoleUtils mock
-        this.consoleUtilsMock = {
-            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.utilsMock = {
-            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.utilsMock.ProgressIndicator(td.matchers.anything())).thenReturn(this.progressIndicator);
-
-        // Replace modules with mocks - do this after setting up all mocks
-        await td.replaceEsm("node:fs", this.fsMock);
-        await td.replaceEsm("node:path", this.path);
-        await td.replaceEsm("../src/consoleUtils.js", this.consoleUtilsMock);
-        await td.replaceEsm("../src/utils.js", this.utilsMock);
-
-        // 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',
-            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.fsMock.writeFileSync('test-file-path.md', 'LLM Response'));
-
-        // Verify success message was displayed
-        td.verify(this.consoleUtilsMock.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.fsMock.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.consoleUtilsMock.displayError(td.matchers.contains('test-file-path.md')));
-        td.verify(this.consoleUtilsMock.displayError('File write error'));
-    });
-});

package/spec/reviewCommand.spec.js

@@ -1,222 +0,0 @@
-import {Command} from 'commander';
-import * as td from 'testdouble';
-
-describe('reviewCommand',  function (){
-
-    beforeEach(async function() {
-        td.reset();
-        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", {
-            SLOTH_INTERNAL_PREAMBLE: '.gsloth.preamble.internal.md',
-            USER_PROJECT_REVIEW_PREAMBLE: '.gsloth.preamble.review.md',
-            slothContext: {
-                config: {},
-                currentDir: '/mock/current/dir'
-            },
-            initConfig: td.function()
-        });
-        const readFileFromCurrentDir = td.function();
-        const readMultipleFilesFromCurrentDir = td.function();
-        const extractLastMessageContent = td.function();
-        const toFileSafeString = td.function();
-        const fileSafeLocalDate = td.function();
-        this.utilsMock = {
-            readFileFromCurrentDir,
-            readMultipleFilesFromCurrentDir,
-            ProgressIndicator: td.constructor(),
-            extractLastMessageContent,
-            toFileSafeString,
-            fileSafeLocalDate
-        };
-        await td.replaceEsm("../src/utils.js", this.utilsMock);
-        td.when(this.utilsMock.readFileFromCurrentDir("test.file")).thenReturn("FILE TO REVIEW");
-        td.when(this.utilsMock.readMultipleFilesFromCurrentDir(["test.file"])).thenReturn("test.file:\n```\nFILE TO REVIEW\n```");
-        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 call review with multiple file contents', async function() {
-        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
-        const program = new Command();
-        await reviewCommand(program, {});
-        td.when(this.utilsMock.readMultipleFilesFromCurrentDir(["test.file", "test2.file"]))
-            .thenReturn("test.file:\n```\nFILE TO REVIEW\n```\n\ntest2.file:\n```\nFILE2 TO REVIEW\n```");
-        await program.parseAsync(['na', 'na', 'review', '-f', 'test.file', 'test2.file']);
-        td.verify(this.review(
-            'sloth-DIFF-review',
-            "INTERNAL PREAMBLE\nPROJECT PREAMBLE",
-            "test.file:\n```\nFILE TO REVIEW\n```\n\ntest2.file:\n```\nFILE2 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", "file")');
-
-        // Verify requirements providers are displayed
-        expect(testOutput.text).toContain('--requirements-provider <requirementsProvider>');
-        expect(testOutput.text).toContain('(choices: "jira-legacy", "text", "file")');
-    });
-
-    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 display meaningful error, when JIRA is enabled, but JIRA token is absent', async function() {
-        const testOutput = { text: '' };
-
-        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
-        const program = new Command();
-        program.configureOutput({
-            writeOut: (str) => testOutput.text += str,
-            writeErr: (str) => testOutput.text += str
-        });
-
-        const context = {
-            config: {
-                requirementsProvider: 'jira-legacy',
-                requirementsProviderConfig: {
-                    'jira-legacy': {
-                        username: 'test-user',
-                        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');
-
-
-        await reviewCommand(program, context);
-        try {
-            await program.parseAsync(['na', 'na', 'pr', 'content-id', 'JIRA-123']);
-        } catch (e) {
-            expect(e.message)
-                .toContain(
-                    'Missing JIRA Legacy API token. ' +
-                    'The legacy token can be defined as JIRA_LEGACY_API_TOKEN environment variable ' +
-                    'or as "token" in config.'
-                );
-        }
-    });
-
-    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(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', 'pr', '123']);
-
-        td.verify(reviewSpy('sloth-PR-123-review', "INTERNAL PREAMBLE\nPROJECT PREAMBLE", "PR Diff Content"));
-    });
-});

package/spec/reviewModule.spec.js

@@ -1,28 +0,0 @@
-import { reviewInner } from '../src/modules/reviewModule.js';
-import { slothContext } from '../src/config.js';
-import { FakeListChatModel } from "@langchain/core/utils/testing";
-import * as td from "testdouble";
-
-describe('reviewModule', () => {
-
-  beforeEach(async function() {
-    td.reset();
-  });
-
-  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

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

@@ -1,27 +0,0 @@
-import { readInternalPreamble } from "../prompt.js";
-import { readMultipleFilesFromCurrentDir } 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
- */
-// eslint-disable-next-line no-unused-vars
-export function askCommand(program, context) {
-    program.command('ask')
-        .description('Ask a question')
-        .argument('<message>', 'A message')
-        .option('-f, --file [files...]', 'Input files. Content of these files will be added BEFORE the message')
-        // TODO add option consuming extra message as argument
-        .action(async (message, options) => {
-            const preamble = [readInternalPreamble()];
-            const content = [message];
-            if (options.file) {
-                content.push(readMultipleFilesFromCurrentDir(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

@@ -1,17 +0,0 @@
-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
- */
-// eslint-disable-next-line no-unused-vars
-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

@@ -1,154 +0,0 @@
-import {Option} from 'commander';
-import {USER_PROJECT_REVIEW_PREAMBLE} from "../config.js";
-import {readInternalPreamble, readPreamble} from "../prompt.js";
-import {readMultipleFilesFromCurrentDir} 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',
-    'file': 'file.js'
-};
-
-/**
- * Content providers. Expected to be in `.providers/` dir
- */
-const CONTENT_PROVIDERS = {
-    'gh': 'ghPrDiffProvider.js',
-    'text': 'text.js',
-    'file': 'file.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
-        .option('-f, --file [files...]', 'Input files. Content of these files 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?.review?.requirementsProvider
-                ?? context.config?.requirementsProvider;
-            const contentProvider = options.contentProvider
-                ?? context.config?.review?.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(readMultipleFilesFromCurrentDir(options.file));
-            }
-            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 [files...]', 'Input files. Content of these files 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?.pr?.requirementsProvider
-                ?? context.config?.requirementsProvider;
-
-            // Handle requirements
-            const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
-            if (requirements) {
-                content.push(requirements);
-            }
-
-            if (options.file) {
-                content.push(readMultipleFilesFromCurrentDir(options.file));
-            }
-
-            // 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 '';
-    }
-}