gaunt-sloth-assistant 0.0.7 → 0.1.0

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,11 +108,18 @@ 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
 
-Currently only vertexai and anthropic can be configured with `gsloth init`.
+Currently vertexai, anthropic and groq can be configured with `gsloth init`.
 
 Populate `.gsloth.preamble.review.md` with your project details and quality requirements.
 Proper preamble is a paramount for good inference.
@@ -98,7 +141,7 @@ export async function configure(importFunction, global) {
     const anthropic = await importFunction('@langchain/anthropic');
     return {
         llm: new anthropic.ChatAnthropic({
-            apiKey: "sk-ant-api03--YOURAPIHASH", // 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"
         })
     };
@@ -127,6 +170,23 @@ export async function configure(importFunction, global) {
 }
 ```
 
+**Example of .gsloth.config.js for Groq**  
+VertexAI usually needs `gcloud auth application-default login`
+(or both `gcloud auth login` and `gcloud auth application-default login`) and does not need any separate API keys.
+```javascript
+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
+        })
+    };
+}
+```
+
 The configure function should simply return instance of langchain [chat model](https://v03.api.js.langchain.com/classes/_langchain_core.language_models_chat_models.BaseChatModel.html).
 See [Langchain documentation](https://js.langchain.com/docs/tutorials/llm_chain/) for more details.
 

package/RELEASE-HOWTO.md

@@ -1,5 +1,13 @@
 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 patch
 git push
@@ -9,4 +17,10 @@ git push --tags
 Note the release version and do 
 ```shell
 gh release create --generate-notes
+```
+
+Publish to NPM
+```shell
+npm login
+npm publish
 ```

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.7",
+  "version": "0.1.0",
   "description": "",
   "license": "MIT",
   "author": "Andrew Kondratev",
@@ -12,21 +12,26 @@
     "npm": ">=10.9.0"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "test-run": "node --trace-deprecation index.js ask \"status check\""
+    "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",
-    "@langchain/langgraph": "^0.2.64",
+    "@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.65",
     "@types/node": "^22.14.1",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "jasmine": "^5.6.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")');
+    });
+});