gaunt-sloth-assistant 0.0.4 → 0.0.8

package/README.md

@@ -76,7 +76,7 @@ Make sure you 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 +98,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 +127,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

@@ -0,0 +1,18 @@
+Make sure `npm config set git-tag-version true` 
+
+```shell
+npm version patch
+git push
+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

@@ -5,6 +5,8 @@
 Doing the following below and making it work stably should be sufficient to call it version 1. 
 
 ### Add tests and gain reasonable coverage
+### Configure eslint for code quality checks
+### Automate release process
 ### Add project init command
 Add a command to init certain model in certain project, for example `gsloth init gemini`
 or `gsloth init` and select one of the provided options. 

package/index.js

@@ -39,7 +39,7 @@ program.command('pr')
             displayError('`gsloth pr` does not expect stdin, use `gsloth review` instead');
             return;
         }
-        displayInfo('Starting review of PR', pr);
+        displayInfo(`Starting review of PR ${pr}`);
         const diff = await getPrDiff(pr);
         const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
         const content = [diff];
@@ -55,7 +55,7 @@ program.command('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 (options) => {
-        if (!slothContext.stdin || options.file) {
+        if (!slothContext.stdin && !options.file) {
             displayError('gsloth review expects stdin with github diff stdin or a file');
             return
         }

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "gaunt-sloth-assistant",
-  "version": "0.0.4",
+  "version": "0.0.8",
   "description": "",
   "license": "MIT",
   "author": "Andrew Kondratev",
   "type": "module",
   "main": "index.js",
+  "repository": "github:andruhon/gaunt-sloth-assistant",
+  "engines": {
+    "node": ">=22.0.0",
+    "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"
@@ -18,10 +22,15 @@
     "@langchain/anthropic": "^0.3.17",
     "@langchain/core": "^0.3.43",
     "@langchain/google-vertexai": "^0.2.3",
+    "@langchain/groq": "^0.2.2",
     "@langchain/langgraph": "^0.2.64",
     "@types/node": "^22.14.1",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "jasmine": "^5.6.0",
+    "jest": "^29.7.0"
   }
 }

package/spec/codeReview.spec.js

@@ -0,0 +1,22 @@
+import { reviewInner } from '../src/codeReview.js';
+import { slothContext } from '../src/config.js';
+import { FakeListChatModel } from "@langchain/core/utils/testing";
+
+describe('codeReview', () => {
+
+  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/codeReview.js

@@ -7,17 +7,36 @@ import {
 } from "@langchain/langgraph";
 import { writeFileSync } from "node:fs";
 import path from "node:path";
-import {initConfig, slothContext} from "./config.js";
+import { initConfig, slothContext } from "./config.js";
 import { display, displayError, displaySuccess } from "./consoleUtils.js";
-import { fileSafeLocalDate, toFileSafeString } from "./utils.js";
-
-await initConfig();
+import { fileSafeLocalDate, toFileSafeString, ProgressIndicator } from "./utils.js";
 
 export async function review(source, preamble, diff) {
+    await initConfig();
+    const progressIndicator = new ProgressIndicator("Reviewing.");
+    const outputContent = await reviewInner(slothContext, () => progressIndicator.indicate(), preamble, diff);
+    const filePath = path.resolve(process.cwd(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
+    process.stdout.write("\n");
+    display(`writing ${filePath}`);
+    process.stdout.write("\n");
+    // TODO highlight LLM output with something like Prism.JS (maybe system emoj are enough ✅⚠️❌)
+    display(outputContent);
+    try {
+        writeFileSync(filePath, outputContent);
+        displaySuccess(`This report can be found in ${filePath}`);
+    } catch (error) {
+        displayError(`Failed to write review to file: ${filePath}`);
+        displayError(error.message);
+        // Consider if you want to exit or just log the error
+        // process.exit(1);
+    }
+}
+
+export async function reviewInner(context, indicateProgress, preamble, diff) {
     // This node receives the current state (messages) and invokes the LLM
     const callModel = async (state) => {
         // state.messages will contain the list including the system preamble and user diff
-        const response = await slothContext.config.llm.invoke(state.messages);
+        const response = await context.config.llm.invoke(state.messages);
         // MessagesAnnotation expects the node to return the new message(s) to be added to the state.
         // Wrap the response in an array if it's a single message object.
         return { messages: response };
@@ -48,24 +67,11 @@ export async function review(source, preamble, diff) {
         },
     ];
 
-    process.stdout.write("Reviewing.");
-    const progress = setInterval(() => process.stdout.write('.'), 1000);
-    const output = await app.invoke({messages}, slothContext.session);
-    const filePath = path.resolve(process.cwd(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
-    display(`writing ${filePath}`);
-    // FIXME this looks ugly, there should be other way
-    const outputContent = output.messages[output.messages.length - 1].content;
+    indicateProgress();
+    // TODO create proper progress indicator for async tasks.
+    const progress = setInterval(() => indicateProgress(), 1000);
+    const output = await app.invoke({messages}, context.session);
     clearInterval(progress);
-    console.log('');
-    // TODO highlight LLM output with something like Prism.JS (maybe system emoj are enough ✅⚠️❌)
-    display(outputContent);
-    try {
-        writeFileSync(filePath, outputContent);
-        displaySuccess(`This report can be found in ${filePath}`);
-    } catch (error) {
-        displayError(`Failed to write review to file: ${filePath}`);
-        displayError(error.message);
-        // Consider if you want to exit or just log the error
-        // process.exit(1);
-    }
+    // FIXME this looks ugly, there should be other way
+    return output.messages[output.messages.length - 1].content;
 }

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 = {
     /**
@@ -29,10 +27,17 @@ 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};
+    const configFileUrl = url.pathToFileURL(path.join(process.cwd(), USER_PROJECT_CONFIG_FILE));    
+    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/prompt.js

@@ -1,6 +1,7 @@
 import {resolve} from "node:path";
 import {SLOTH_INTERNAL_PREAMBLE, slothContext} from "./config.js";
 import {readFileSyncWithMessages, spawnCommand} from "./utils.js";
+import { displayError } from "./consoleUtils.js";
 
 export function readInternalPreamble() {
     const filePath = resolve(slothContext.installDir, SLOTH_INTERNAL_PREAMBLE);
@@ -18,8 +19,15 @@ export function readPreamble(preambleFilename) {
 
 /**
  * This function expects https://cli.github.com/ to be installed and authenticated.
+ * It does something like `gh pr diff 42`
  */
 export async function getPrDiff(pr) {
     // TODO makes sense to check if gh is available and authenticated
-    return spawnCommand('gh', ['pr', 'diff', pr], 'Loading PR diff...', 'Loaded PR diff.');
+    try {
+        return await spawnCommand('gh', ['pr', 'diff', pr], 'Loading PR diff...', 'Loaded PR diff.');
+    } catch (e) {
+        displayError(e.toString());
+        displayError(`Failed to call "gh pr diff ${pr}", see message above for details.`);
+        process.exit();
+    }
 }

package/src/utils.js

@@ -1,6 +1,6 @@
 import {display, displayError, displaySuccess, displayWarning} from "./consoleUtils.js";
 import {existsSync, readFileSync, writeFileSync} from "node:fs";
-import {slothContext, USER_PROJECT_REVIEW_PREAMBLE} from "./config.js";
+import {slothContext} from "./config.js";
 import {resolve} from "node:path";
 import {spawn} from "node:child_process";
 
@@ -63,7 +63,7 @@ export function readStdin(program) {
             }
         });
         process.stdin.on('end', function() {
-            console.log('');
+            process.stdout.write('.\n');
             program.parse(process.argv);
         });
     }
@@ -71,18 +71,27 @@ export function readStdin(program) {
 
 export async function spawnCommand(command, args, progressMessage, successMessage) {
     return new Promise((resolve, reject) => {
-        const out = {stdout: ''};
+        const out = {stdout: '', stderr: ''};
         const spawned = spawn(command, args);
-        spawned.stdout.on('data', async (stdoutChunk) => {
+        spawned.stdout.on('data', async (stdoutChunk, dd) => {
             display(progressMessage);
             out.stdout += stdoutChunk.toString();
         });
+        spawned.stderr.on('data', (err) => {
+            displayError(progressMessage);
+            out.stderr += err.toString();
+        })
         spawned.on('error', (err) => {
-            reject(err);
+            reject(err.toString());
         })
         spawned.on('close', (code) => {
-            display(successMessage);
-            resolve(out.stdout);
+            if (code === 0) {
+                display(successMessage);
+                resolve(out.stdout);
+            } else {
+                displayError(`Failed to spawn command with code ${code}`);
+                reject(out.stdout + ' ' + out.stderr);
+            }
         });
     });
 }
@@ -92,3 +101,22 @@ export function getSlothVersion() {
     const projectJson = readFileSync(jsonPath, { encoding: 'utf8' });
     return JSON.parse(projectJson).version;
 }
+
+
+export class ProgressIndicator {
+
+    constructor(initialMessage) {
+        this.hasBeenCalled = false;
+        this.initialMessage = initialMessage;
+    }
+    
+    indicate() {
+        if (this.hasBeenCalled) {
+            process.stdout.write('.');
+        } else {
+            this.hasBeenCalled = true;
+            process.stdout.write(this.initialMessage);
+        }
+    }
+
+}