gaunt-sloth-assistant 0.0.8 → 0.1.1

package/DEVELOPMENT.md

@@ -0,0 +1,9 @@
+# Installation
+
+## GitHub (master)
+
+```shell
+git clone https://github.com/andruhon/gaunt-sloth.git
+npm install
+npm install -g ./
+```

package/README.md

@@ -1,13 +1,19 @@
 # Gaunt Sloth Assistant
-Simplistic assistant helping to do code reviews from command line based on [Langchain.js](https://github.com/langchain-ai/langchainjs)
+Simplistic AI assistant helping to do **code reviews from command line** based on [Langchain.js](https://github.com/langchain-ai/langchainjs)
+
+## Review PR (Pull Request)
+To review PR by PR number:
+
+First make sure the official [GitHub cli (gh)](https://cli.github.com/) is installed
+and authenticated to have access to your project.
+
+Open terminal (command line) in your project directory.
+
+Type command: `gsloth pr [desired pull request number]`, for example:
 
-## Review PR
-Review PR by PR number:
 ```shell
 gsloth pr 42
 ``` 
-Official [GitHub cli (gh)](https://cli.github.com/) should be installed
-and authenticated to have access to your project.
 
 Review providing markdown file with requirements and notes.
 ```shell
@@ -19,6 +25,44 @@ open Jira XML with "Export XML" in jira and to copy `<description></description>
 This block contains HTML and AI understands it easily 
 (most importantly it understand nested lists like ul>li).
 
+## JIRA Integration
+
+When JIRA integration is configured, the JIRA issue text can be included alongside the diff for review.
+The project review preamble can be modified to reject a pull request immediately
+if it appears to implement something different from what was requested in the requirements.
+
+The command syntax is generally `gsloth pr <prId> [requirementsId]`,
+for example, the snippet below does review of PR 42 and
+supplies description of JIRA issue with number PP-4242:
+
+```shell
+gsloth pr 42 PP-4242
+```
+
+Example configuration setting up JIRA integration using a legacy API token.
+Make sure you use your actual company domain in `baseUrl` and your personal legacy `token`.
+
+A legacy token can be acquired from `Atlassian Account Settings -> Security -> Create and manage API tokens`.
+
+```javascript
+export async function configure(importFunction, global) {
+    const vertexAi = await importFunction('@langchain/google-vertexai');
+    return {
+        llm: new vertexAi.ChatVertexAI({
+            model: "gemini-2.5-pro-exp-03-25"
+        }),
+        requirementsProvider: 'jira-legacy',
+        requirementsProviderConfig: {
+            'jira-legacy': {
+                username: 'andrei.kondratev@unimarket.com', // Your Jira username/email
+                token: 'YOURSECRETTOKEN',     // Replace with your real Jira API token
+                baseUrl: 'https://yourcompany.atlassian.net/rest/api/2/issue/'  // Your Jira instance base URL
+            }
+        }
+    }
+}
+```
+
 ## Review any Diff
 ```shell
 git --no-pager diff origin/master...yourgitcommithash | gsloth review
@@ -48,14 +92,6 @@ Tested with Node 22 LTS.
 npm install gaunt-sloth-assistant -g
 ```
 
-## GitHub (master)
-
-```shell
-git clone https://github.com/andruhon/gaunt-sloth.git
-npm install
-npm install -g ./
-```
-
 ## Configuration
 Go to your project directory and init sloth with vendor of your choice.
 
@@ -72,7 +108,14 @@ gcloud auth application-default login
 cd ./your-project
 gsloth init anthropic
 ```
-Make sure you edit `.gsloth.config.js` and set up your key.
+Make sure you either define `ANTHROPIC_API_KEY` environment variable or edit `.gsloth.config.js` and set up your key.
+
+### Groq
+```shell
+cd ./your-project
+gsloth init groq
+```
+Make sure you either define `GROQ_API_KEY` environment variable or edit `.gsloth.config.js` and set up your key.
 
 ### Further configuration
 

package/RELEASE-HOWTO.md

@@ -1,11 +1,19 @@
 Make sure `npm config set git-tag-version true` 
 
+For patch, e.g., from 0.0.8 to 0.0.9
 ```shell
 npm version patch
 git push
 git push --tags
 ```
 
+For minor, e.g., from 0.0.8 to 0.1.0
+```shell
+npm version minor
+git push
+git push --tags
+```
+
 Note the release version and do 
 ```shell
 gh release create --generate-notes

package/ROADMAP.md

@@ -4,7 +4,7 @@
 ## 1.0.0
 Doing the following below and making it work stably should be sufficient to call it version 1. 
 
-### Add tests and gain reasonable coverage
+### ⌛Add tests and gain reasonable coverage
 ### Configure eslint for code quality checks
 ### Automate release process
 ### Add project init command
@@ -12,7 +12,7 @@ Add a command to init certain model in certain project, for example `gsloth init
 or `gsloth init` and select one of the provided options. 
 -[x] VertexAI
 -[x] Anthropic
--[ ] Groq
+-[x] Groq
 -[ ] Local LLm 
 ### Allow global configuration
 ### Streamline and stabilize configuration

package/UX-RESEARCH.md

@@ -0,0 +1,78 @@
+# UX Research
+
+## Currently available commands:
+```
+gsloth --help
+Usage: gsloth [options] [command]
+
+Gaunt Sloth Assistant reviewing your PRs
+
+Options:
+  -V, --version            output the version number
+  -h, --help               display help for command
+
+Commands:
+  init <type>              Initialize the Gaunt Sloth Assistant in your project.
+                           This will write necessary config files.
+  pr [options] <prNumber>  Review a PR in current git directory (assuming that
+                           GH cli is installed and authenticated for current
+                           project
+  review [options]         Review provided diff or other content
+  ask [options] <message>  Ask a question
+  help [command]           display help for command
+```
+
+pr (we decided to rename it to r as shortcut for review with pull request provider)
+```
+gsloth pr --help
+Usage: gsloth pr [options] <prNumber>
+
+Review a PR in current git directory (assuming that GH cli is installed and
+authenticated for current project
+
+Arguments:
+  prNumber           PR number to review
+
+Options:
+  -f, --file <file>  Input file. Context of this file will be added BEFORE the
+                     diff
+  -h, --help         display help for command
+```
+
+ask
+```
+gsloth ask --help
+Usage: gsloth ask [options] <message>
+
+Ask a question
+
+Arguments:
+  message            A message
+
+Options:
+  -f, --file <file>  Input file. Context of this file will be added BEFORE the
+                     diff
+  -h, --help         display help for command
+```
+
+review (lacks documentaion, it also accepts pipe with stdin)
+```
+gsloth review --help
+Usage: gsloth review [options]
+
+Review provided diff or other content
+
+Options:
+  -f, --file <file>  Input file. Context of this file will be added BEFORE the
+                     diff
+  -h, --help         display help for command
+```
+
+## Future functions
+
+- JIRA. We need to privide a jira number as a criteria, this should somehow go through separate provider and using config from .gsloth.config.
+- External links (simple public links)
+- Editing files
+- Improve experience with specs or criteria (or requirements?)
+- Should we allow to mention that the data is diff or plain code? Maybe we can somehow deduct it or ask smaller model to guess?
+- Slot editing local files

package/index.js

@@ -1,16 +1,12 @@
 #!/usr/bin/env node
-import {Argument, Command} from 'commander';
-import {dirname} from 'node:path';
-import {displayError, displayInfo} from "./src/consoleUtils.js";
-import {
-    availableDefaultConfigs,
-    createProjectConfig,
-    slothContext,
-    USER_PROJECT_REVIEW_PREAMBLE
-} from "./src/config.js";
-import {fileURLToPath} from "url";
-import {getSlothVersion, readFileFromCurrentDir, readStdin} from "./src/utils.js";
-import {getPrDiff, readInternalPreamble, readPreamble} from "./src/prompt.js";
+import { Command } from 'commander';
+import { dirname } from 'node:path';
+import { fileURLToPath } from "url";
+import { reviewCommand } from "./src/commands/reviewCommand.js";
+import { initCommand } from "./src/commands/initCommand.js";
+import { askCommand } from "./src/commands/askCommand.js";
+import { slothContext } from "./src/config.js";
+import { getSlothVersion, readStdin } from "./src/utils.js";
 
 const program = new Command();
 
@@ -22,70 +18,12 @@ program
     .description('Gaunt Sloth Assistant reviewing your PRs')
     .version(getSlothVersion());
 
-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);
-    });
+initCommand(program, slothContext);
 
-program.command('pr')
-    .description('Review a PR in current git directory (assuming that GH cli is installed and authenticated for current project')
-    .argument('<prNumber>', 'PR number to review')
-    .option('-f, --file <file>', 'Input file. Context of this file will be added BEFORE the diff')
-    // TODO add option consuming extra message as argument
-    .action(async (pr, options) => {
-        if (slothContext.stdin) {
-            displayError('`gsloth pr` does not expect stdin, use `gsloth review` instead');
-            return;
-        }
-        displayInfo(`Starting review of PR ${pr}`);
-        const diff = await getPrDiff(pr);
-        const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
-        const content = [diff];
-        if (options.file) {
-            content.push(readFileFromCurrentDir(options.file));
-        }
-        const { review } = await import('./src/codeReview.js');
-        await review('sloth-PR-review-'+pr, preamble.join("\n"), content.join("\n"));
-    });
+reviewCommand(program, slothContext)
 
-program.command('review')
-    .description('Review provided diff or other content')
-    .option('-f, --file <file>', 'Input file. Context of this file will be added BEFORE the diff')
-    // TODO add option consuming extra message as argument
-    .action(async (options) => {
-        if (!slothContext.stdin && !options.file) {
-            displayError('gsloth review expects stdin with github diff stdin or a file');
-            return
-        }
-        const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
-        const content = [];
-        if (slothContext.stdin) {
-            content.push(slothContext.stdin);
-        }
-        if (options.file) {
-            content.push(readFileFromCurrentDir(options.file));
-        }
-        const { review } = await import('./src/codeReview.js');
-        await review('sloth-DIFF-review', preamble.join("\n"), content.join("\n"));
-    });
-
-program.command('ask')
-    .description('Ask a question')
-    .argument('<message>', 'A message')
-    .option('-f, --file <file>', 'Input file. Context 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));
-        }
-        const { askQuestion } = await import('./src/questionAnswering.js');
-        await askQuestion('sloth-ASK', preamble.join("\n"), content.join("\n"));
-    });
+askCommand(program, slothContext);
 
 // TODO add general interactive chat command
 
-readStdin(program);
+await readStdin(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaunt-sloth-assistant",
-  "version": "0.0.8",
+  "version": "0.1.1",
   "description": "",
   "license": "MIT",
   "author": "Andrew Kondratev",
@@ -15,15 +15,16 @@
     "test": "jasmine"
   },
   "bin": {
-    "gsloth": "index.js"
+    "gsloth": "index.js",
+    "gth": "index.js"
   },
   "dependencies": {
-    "@eslint/js": "^9.24.0",
-    "@langchain/anthropic": "^0.3.17",
-    "@langchain/core": "^0.3.43",
-    "@langchain/google-vertexai": "^0.2.3",
+    "@eslint/js": "^9.25.0",
+    "@langchain/anthropic": "^0.3.18",
+    "@langchain/core": "^0.3.45",
+    "@langchain/google-vertexai": "^0.2.4",
     "@langchain/groq": "^0.2.2",
-    "@langchain/langgraph": "^0.2.64",
+    "@langchain/langgraph": "^0.2.65",
     "@types/node": "^22.14.1",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
@@ -31,6 +32,6 @@
   },
   "devDependencies": {
     "jasmine": "^5.6.0",
-    "jest": "^29.7.0"
+    "testdouble": "^3.20.2"
   }
 }

package/spec/.gsloth.config.js

@@ -0,0 +1,22 @@
+export async function configure(importFunction, global) {
+    const test = await importFunction('@langchain/core/utils/testing');
+    return {
+        llm: new test.FakeListChatModel({
+            responses: ["First LLM message", "Second LLM message"],
+        }),
+        requirementsProviderConfig: {
+            'jira-legacy': {
+                username: 'user.name@company.com', // Your Jira username/email
+                token: 'YoUrToKeN',     // Replace with your real Jira API token
+                baseUrl: 'https://company.atlassian.net/rest/api/2/issue/'  // Your Jira instance base URL
+            }
+        },
+        requirementsProvider: "jira-legacy",
+        contentProvider: "somethingSpecial",
+        contentProviderConfig: {
+            somethingSpecial: {
+                test: 'example'
+            }
+        }
+    }
+}

package/spec/askCommand.spec.js

@@ -0,0 +1,58 @@
+import {Command} from 'commander';
+import * as td from 'testdouble';
+
+describe('askCommand', function (){
+
+    beforeEach(async function() {
+        this.askQuestion = td.function();
+        this.prompt = await td.replaceEsm("../src/prompt.js");
+        td.when(this.prompt.readInternalPreamble()).thenReturn("INTERNAL PREAMBLE");
+        this.questionAnsweringMock = await td.replaceEsm("../src/modules/questionAnsweringModule.js");
+        await td.replaceEsm("../src/config.js");
+        this.utils = await td.replaceEsm("../src/utils.js");
+        td.when(this.utils.readFileFromCurrentDir("test.file")).thenReturn("FILE CONTENT");
+        td.when(this.questionAnsweringMock.askQuestion(
+            'sloth-ASK',
+            td.matchers.anything(),
+            td.matchers.anything())
+        ).thenDo(this.askQuestion);
+    });
+
+    it('Should call askQuestion with message', async function() {
+        const { askCommand } = await import("../src/commands/askCommand.js");
+        const program = new Command();
+        await askCommand(program, {});
+        await program.parseAsync(['na', 'na', 'ask', 'test message']);
+        td.verify(this.askQuestion('sloth-ASK', "INTERNAL PREAMBLE", "test message"));
+    });
+
+    it('Should call askQuestion with message and file content', async function() {
+        const { askCommand } = await import("../src/commands/askCommand.js");
+        const program = new Command();
+        await askCommand(program, {});
+        await program.parseAsync(['na', 'na', 'ask', 'test message', '-f', 'test.file']);
+        td.verify(this.askQuestion('sloth-ASK', "INTERNAL PREAMBLE", "test message\nFILE CONTENT"));
+    });
+
+    it('Should display help correctly', async function() {
+        const { askCommand } = await import("../src/commands/askCommand.js");
+        const program = new Command();
+        const testOutput = { text: '' };
+
+        program.configureOutput({
+            writeOut: (str) => testOutput.text += str,
+            writeErr: (str) => testOutput.text += str
+        });
+
+        await askCommand(program, {});
+
+        const commandUnderTest = program.commands.find(c => c.name() == 'ask');
+        expect(commandUnderTest).toBeDefined();
+        commandUnderTest.outputHelp();
+
+        // Verify help content
+        expect(testOutput.text).toContain('Ask a question');
+        expect(testOutput.text).toContain('<message>');
+        expect(testOutput.text).toContain('-f, --file');
+    });
+});

package/spec/initCommand.spec.js

@@ -0,0 +1,54 @@
+import {Command} from 'commander';
+import * as td from 'testdouble';
+
+describe('initCommand', function (){
+
+    beforeEach(async function() {
+        // Create a mock for createProjectConfig
+        this.createProjectConfig = td.function();
+
+        // Replace the config module
+        await td.replaceEsm("../src/config.js", {
+            createProjectConfig: this.createProjectConfig,
+            availableDefaultConfigs: ['vertexai', 'anthropic', 'groq'],
+            SLOTH_INTERNAL_PREAMBLE: '.gsloth.preamble.internal.md',
+            USER_PROJECT_REVIEW_PREAMBLE: '.gsloth.preamble.review.md',
+            USER_PROJECT_CONFIG_FILE: '.gsloth.config.js',
+            slothContext: {
+                installDir: '/mock/install/dir',
+                currentDir: '/mock/current/dir',
+                config: {},
+                session: {}
+            }
+        });
+    });
+
+    it('Should call createProjectConfig with the provided config type', async function() {
+        const { initCommand } = await import("../src/commands/initCommand.js");
+        const program = new Command();
+        await initCommand(program, {});
+        await program.parseAsync(['na', 'na', 'init', 'vertexai']);
+        td.verify(this.createProjectConfig('vertexai'));
+    });
+
+    it('Should display available config types in help', async function() {
+        const { initCommand } = await import("../src/commands/initCommand.js");
+        const program = new Command();
+        const testOutput = { text: '' };
+
+        program.configureOutput({
+            writeOut: (str) => testOutput.text += str,
+            writeErr: (str) => testOutput.text += str
+        });
+
+        await initCommand(program, {});
+
+        const commandUnderTest = program.commands.find(c => c.name() == 'init');
+        expect(commandUnderTest).toBeDefined();
+        commandUnderTest.outputHelp();
+
+        // Verify available config types are displayed
+        expect(testOutput.text).toContain('<type>');
+        expect(testOutput.text).toContain('(choices: "vertexai", "anthropic", "groq")');
+    });
+});

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