gaunt-sloth-assistant 0.0.3

package/.eslint.config.mjs

@@ -0,0 +1,72 @@
+// TODO
+// // eslint.config.mjs
+// // Remember to install dependencies:
+// // npm install --save-dev eslint @eslint/js eslint-plugin-n globals eslint-config-prettier
+// // yarn add --dev eslint @eslint/js eslint-plugin-n globals eslint-config-prettier
+// // pnpm add -D eslint @eslint/js eslint-plugin-n globals eslint-config-prettier
+//
+// import js from "@eslint/js"; // Provides eslint:recommended and eslint:all
+// import pluginN from "eslint-plugin-n"; // Successor to eslint-plugin-node
+// import globals from "globals"; // Provides standard global variables (node, browser, etc.)
+// import eslintConfigPrettier from "eslint-config-prettier"; // Disables rules that conflict with Prettier
+//
+// export default [
+//     // 1. Global Ignores
+//     // Files/directories to ignore globally. You can add more patterns.
+//     {
+//         ignores: [
+//             "node_modules/",
+//             "dist/", // Common build output directory
+//             "build/",  // Another common build output directory
+//             ".env",
+//             "*.log",
+//             "coverage/", // Test coverage reports
+//         ],
+//     },
+//
+//     // 2. ESLint Recommended Rules
+//     // Provides a good baseline set of rules maintained by the ESLint team.
+//     js.configs.recommended,
+//
+//     // 3. Node.js Specific Rules (using eslint-plugin-n)
+//     // Recommended configuration for Node.js projects.
+//     pluginN.configs['flat/recommended'],
+//
+//     // 4. Custom Configuration for your JS/MJS files
+//     {
+//         files: ["**/*.{js,mjs}"], // Apply these settings to .js and .mjs files
+//         languageOptions: {
+//             ecmaVersion: "latest", // Use the latest ECMAScript features
+//             sourceType: "module",  // Set to "module" for ES Modules (import/export)
+//             globals: {
+//                 ...globals.nodeBuiltin, // Includes Node.js built-in globals like 'process', 'Buffer', etc.
+//                 // Add other global environments if needed:
+//                 // ...globals.browser, // If your code also runs in the browser
+//                 // Add any other custom global variables your project uses:
+//                 // myCustomGlobal: "readonly",
+//             }
+//         },
+//         rules: {
+//             // Customize or override rules here
+//             "no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }], // Warn about unused vars, except those starting with _
+//             "semi": ["error", "always"], // Enforce semicolons
+//             "quotes": ["warn", "single"], // Prefer single quotes
+//             "indent": ["warn", 2],        // Enforce 2-space indentation
+//
+//             // Node specific rule examples (from eslint-plugin-n) - adjust as needed
+//             "n/no-unpublished-import": ["error", {
+//                 "allowModules": [], // Add exceptions for modules used in dev but not in dependencies
+//             }],
+//             "n/no-missing-import": "error", // Ensure imports can be resolved
+//             "n/no-extraneous-import": "error", // Prevent importing devDependencies in production code
+//
+//             // Add other rules or modify existing ones based on your team's style guide
+//         }
+//     },
+//
+//     // 5. Prettier Configuration (Optional but Recommended)
+//     // IMPORTANT: This MUST be the LAST configuration object in the array.
+//     // It disables ESLint rules that would conflict with Prettier's formatting.
+//     // Assumes you are using Prettier for code formatting.
+//     eslintConfigPrettier,
+// ];

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

package/.gsloth.preamble.internal.md

@@ -0,0 +1,4 @@
+Your name is Gaunt Sloth, you are an elite programmer who knows all programming languages excellently.
+You do not care much about pleasing other people; your primary concern is the correctness of code and the absence of bugs, but you are always polite.
+
+Don't hesitate to use ✅, ⚠️ and ❌ symbols to highlight your feedback appropriately.

package/.gsloth.preamble.review.md

@@ -0,0 +1,124 @@
+You are conducting LangChain.js/LangGraph.js Node.JS code review.
+
+# Code Review Guidelines for LangChain.js/LangGraph.js Projects
+
+## Core Review Principles
+
+### Architecture and Flow
+- Verify proper separation of LangChain components (LLMs, chains, agents, tools)
+- Check for clear data flow between components
+- Ensure proper state management in LangGraph workflows
+- Validate error handling and fallback mechanisms
+
+### Performance Considerations
+- Review chunking strategies for large inputs
+- Check for proper caching implementation
+- Verify memory management for conversation chains
+- Assess streaming implementation where applicable
+
+### Security
+- Validate API key handling and environment variables
+- Check for proper input sanitization
+- Review rate limiting implementation
+- Verify output validation and sanitization
+
+## Technical Checklist
+
+### LangChain.js Specific
+- [ ] Proper chain composition and sequencing
+- [ ] Correct prompt template formatting
+- [ ] Appropriate memory implementation
+- [ ] Tool configuration and validation
+- [ ] Output parser implementation
+- [ ] Model configuration and defaults
+
+### LangGraph.js Specific
+- [ ] State machine definition correctness
+- [ ] Edge case handling in workflows
+- [ ] Proper node transitions
+- [ ] State persistence strategy
+- [ ] Graph visualization implementation (if applicable)
+
+### General Code Quality
+- [ ] TypeScript type definitions
+- [ ] Async/await implementation
+- [ ] Error boundary definition
+- [ ] Logging implementation
+- [ ] Test coverage
+- [ ] Documentation quality
+
+## Best Practices
+
+### Configuration
+Make sure that API keys are accidentally not included into diff.
+
+### Common Pitfalls to Check
+1. Improper chain composition
+2. Missing error handlers
+3. Memory leaks in long-running chains
+4. Incorrect prompt engineering
+5. Inadequate rate limiting
+6. Missing type definitions
+7. Improper streaming implementation
+
+### Performance Optimization Points
+1. Caching strategy
+2. Batch processing implementation
+3. Connection pooling
+4. Resource cleanup
+5. Memory management
+
+## Testing Requirements
+
+### Unit Tests
+- Individual chain components
+- Tool implementations
+- Parser functions
+- State transitions
+
+### Integration Tests
+- End-to-end workflows
+- External API interactions
+- Error scenarios
+- State persistence
+
+### Load Tests
+- Concurrent request handling
+- Memory usage under load
+- Response time benchmarks
+
+## Documentation Requirements
+
+1. Architecture overview
+2. Component interaction diagrams
+3. Configuration guide
+4. API documentation
+5. Error handling guide
+6. Performance optimization guide
+7. Deployment checklist
+
+## Monitoring and Observability
+
+### Metrics to Track
+- Chain execution times
+- Token usage
+- Error rates
+- Memory consumption
+- API latencies
+
+### Logging Requirements
+- Request/response pairs
+- Error stack traces
+- Performance metrics
+- State transitions
+- Resource usage
+
+---
+
+Provide specific feedback on any areas of concern or suggestions for improvement. Please categorize your feedback (e.g., "Bug," "Suggestion," "Nitpick").
+
+Important! In the end conclude if you would recommend to approve this PR or not. Use ✅⚠️❌ symbols to highlight your feedback appropriately.
+
+Thank you for your thorough review!
+
+Important! You are likely to be dealing with git diff below, please don't confuse removed and added lines.

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025-present Andrew Kondratev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# Gaunt Sloth Assistant
+Simplistic assistant helping to do code reviews from command line based on [Langchain.js](https://github.com/langchain-ai/langchainjs)
+
+## Review PR
+`gsloth pr 42` - review PR by PR number.
+Official [GitHub cli (gh)](https://cli.github.com/) should be installed
+and authenticated to have access to your project.
+
+`gsloth pr 42 -f PROJ-1234.md` - Review providing MD file with requirements and notes. 
+Jira integration is in [ROADMAP](ROADMAP.md).
+Currently, the easiest ***meaningful*** way to add jira description is to
+open Jira XML with "Export XML" in jira and to copy `<description></description>` block.
+This block contains HTML and AI understands it easily 
+(most importantly it understand nested lists like ul>li).
+
+## Review Diff
+`git --no-pager diff origin/master...ffd079c134eabf18d85975f155b76d62a895cdec | gsloth review`
+(May be helpful to review subset of PR)
+
+## Question Answering
+`gsloth ask "which types of primitives are available in JavaScript?"`
+
+`gsloth ask "Please have a look at this file" -f index.js`
+
+## Installation
+There's no npm module yet. Do `npm install -g ./` to install local build globally to your machine.
+```
+git clone https://github.com/andruhon/gaunt-sloth.git
+npm install
+npm install -g ./
+```
+
+## Configuration
+There is no global configuration yet. The project you want to get reviewed needs gsloth configuration.
+
+Add `.gsloth.preamble.review.md` to your project.
+Add general description of what your project is and what do you expect from this code review.
+Check [.gsloth.preamble.review.md](.gsloth.preamble.review.md) for example.
+
+Add `.gsloth.config.js,` to your project.
+
+**Example of .gsloth.config.js for Anthropic**  
+```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
+    // At a moment only google-vertexai and anthropic packaged with Sloth, but you can install support for any other langchain llms
+    const anthropic = await importFunction('@langchain/anthropic');
+    return {
+        llm: new anthropic.ChatAnthropic({
+            apiKey: "sk-ant-api03--YOURAPIHASH", // You should put your API hash here
+            model: "claude-3-5-sonnet-20241022"
+        })
+    };
+}
+
+```
+
+**Example of .gsloth.config.js for VertexAI**  
+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
+    // At a moment only google-vertexai and anthropic packaged with Sloth, but you can install support for any other langchain llms
+    // Note: for vertex AI you likely to need to do `gcloud auth login`
+    const vertexAi = await importFunction('@langchain/google-vertexai');
+    return {
+        llm: new vertexAi.ChatVertexAI({
+            model: "gemini-2.5-pro-exp-03-25", // Consider checking for latest recommended model versions
+            temperature: 0,
+            //// Other parameters might be relevant depending on Vertex AI API updates.
+            //// The project is not in the interface, but it is in documentation and it seems to work.
+            // project: 'your-cool-google-cloud-project',
+        })
+    }
+}
+```
+
+## License
+License is [MIT](https://opensource.org/license/mit). See [LICENSE](LICENSE)
+

package/ROADMAP.md

@@ -0,0 +1,34 @@
+# Gaunt Sloth Assistant roadmap
+
+
+## 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 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. 
+-[x] VertexAI
+-[x] Anthropic
+-[ ] Groq
+-[ ] Local LLm 
+### Allow global configuration
+### Streamline and stabilize configuration
+### Add JIRA legacy token integration plugin
+### Teach assistant to identify important files and include their contents into prompt
+The idea is to ask smaller model like flash to find important files from diff then pick them up and include into prompt.
+### Teach assistant to access provided public web links
+### Consider adding an option to always include certain source code files into prompt
+### Test with Groq
+### Add general chat command
+
+## Extra stuff for later
+
+### Modify local files within project (gsloth code)
+Expected guardrails:
+- Make sure it does not go outside project directory
+- Make sure project has git (or later other vcs)
+- Make sure that local changes are stashed if any present
+
+### Index project into Vector DB
+

package/index.js

@@ -0,0 +1,91 @@
+#!/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";
+
+const program = new Command();
+
+slothContext.currentDir = process.cwd();
+slothContext.installDir = dirname(fileURLToPath(import.meta.url))
+
+program
+    .name('gsloth')
+    .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);
+    });
+
+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"));
+    });
+
+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"));
+    });
+
+// TODO add general interactive chat command
+
+readStdin(program);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "gaunt-sloth-assistant",
+  "version": "0.0.3",
+  "description": "",
+  "license": "MIT",
+  "author": "Andrew Kondratev",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "test-run": "node --trace-deprecation index.js ask \"status check\""
+  },
+  "bin": {
+    "gsloth": "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.62",
+    "@types/node": "^22.14.1",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "uuid": "^11.1.0"
+  }
+}

package/src/codeReview.js

@@ -0,0 +1,71 @@
+import {
+    END,
+    MemorySaver,
+    MessagesAnnotation,
+    START,
+    StateGraph,
+} from "@langchain/langgraph";
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import {initConfig, slothContext} from "./config.js";
+import { display, displayError, displaySuccess } from "./consoleUtils.js";
+import { fileSafeLocalDate, toFileSafeString } from "./utils.js";
+
+await initConfig();
+
+export async function review(source, 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);
+        // 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 };
+    };
+
+    // Define the graph structure with MessagesAnnotation state
+    const workflow = new StateGraph(MessagesAnnotation)
+        // Define the node and edge
+        .addNode("model", callModel)
+        .addEdge(START, "model") // Start at the 'model' node
+        .addEdge("model", END); // End after the 'model' node completes
+
+    // Set up memory (optional but good practice for potential future multi-turn interactions)
+    const memory = new MemorySaver(); // TODO extract to config
+
+    // Compile the workflow into a runnable app
+    const app = workflow.compile({ checkpointer: memory });
+
+    // Construct the initial the messages including the preamble as a system message
+    const messages = [
+        {
+            role: "system",
+            content: preamble, // The preamble goes here
+        },
+        {
+            role: "user",
+            content: diff, // The code diff goes here
+        },
+    ];
+
+    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;
+    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);
+    }
+}

package/src/config.js

@@ -0,0 +1,58 @@
+import path, {dirname} 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";
+
+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 slothContext = {
+    /**
+     * Directory where the sloth is installed.
+     * index.js should set up this.
+     */
+    installDir: null,
+    /**
+     * Directory where the sloth has been invoked. Usually user's project root.
+     * index.js should set up this.
+     */
+    currentDir: null,
+    config: null,
+    stdin: '',
+    session: {configurable: {thread_id: uuidv4()}}
+};
+
+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};
+}
+
+export async function createProjectConfig(configType) {
+    displayInfo(`Setting up your project\n`);
+    writeProjectReviewPreamble();
+    displayWarning(`Make sure you add as much detail as possible to your ${USER_PROJECT_REVIEW_PREAMBLE}.\n`)
+
+    displayInfo(`Creating project config for ${configType}`);
+    const vendorConfig = await import(`./configs/${configType}.js`);
+    vendorConfig.init(USER_PROJECT_CONFIG_FILE, slothContext);
+}
+
+function writeProjectReviewPreamble() {
+    let reviewPreamblePath = path.join(slothContext.currentDir, USER_PROJECT_REVIEW_PREAMBLE);
+    writeFileIfNotExistsWithMessages(
+        reviewPreamblePath,
+        'You are doing generic code review.\n'
+        + 'Important! Please remind user to prepare proper AI preamble in ' +
+        + USER_PROJECT_REVIEW_PREAMBLE
+        + 'for this project. Use decent amount of ⚠️ to highlight lack of config. '
+        + 'Explicitly mention `'+ USER_PROJECT_REVIEW_PREAMBLE + '`.'
+    );
+}

package/src/configs/anthropic.js

@@ -0,0 +1,25 @@
+import {writeFileIfNotExistsWithMessages} from "../utils.js";
+import path from "node:path";
+import {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
+    // At a moment only google-vertexai and anthropic packaged with Sloth, but you can install support for any other langchain llms
+    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
+            model: "claude-3-5-sonnet-20241022" // Don't forget to check new models availability.
+        })
+    };
+}
+`;
+
+export function init(configFileName, context) {
+    path.join(context.currentDir, configFileName);
+    writeFileIfNotExistsWithMessages(configFileName, content);
+    displayWarning(`You need to update your ${USER_PROJECT_CONFIG_FILE} to add your Anthropic API key.`);
+}

package/src/configs/vertexai.js

@@ -0,0 +1,26 @@
+import {writeFileIfNotExistsWithMessages} from "../utils.js";
+import path from "node:path";
+import {displayWarning} from "../consoleUtils.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 vertexAi = await importFunction('@langchain/google-vertexai');
+    return {
+        llm: new vertexAi.ChatVertexAI({
+            model: "gemini-2.5-pro-exp-03-25", // Consider checking for latest recommended model versions
+            // temperature: 0,
+            // Other parameters might be relevant depending on Vertex AI API updates
+            // The project is not in the interface, but it is in documentation (seems to work unimarket-development as well)
+            // project: 'your-cool-gcloud-project'
+        })
+    }
+}
+`;
+
+export function init(configFileName, context) {
+    path.join(context.currentDir, configFileName);
+    writeFileIfNotExistsWithMessages(configFileName, content);
+    displayWarning("For Google VertexAI you likely to need to do `gcloud auth login` and `gcloud auth application-default login`.");
+}

package/src/consoleUtils.js

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+
+export function displayError (message) {
+    console.error(chalk.red(message));
+}
+
+export function displayWarning (message) {
+    console.error(chalk.yellow(message));
+}
+
+export function displaySuccess (message) {
+    console.error(chalk.green(message));
+}
+
+export function displayInfo (message) {
+    console.error(chalk.blue(message));
+}
+
+export function display(message) {
+    console.log(message);
+}

package/src/prompt.js

@@ -0,0 +1,25 @@
+import {resolve} from "node:path";
+import {SLOTH_INTERNAL_PREAMBLE, slothContext} from "./config.js";
+import {readFileSyncWithMessages, spawnCommand} from "./utils.js";
+
+export function readInternalPreamble() {
+    const filePath = resolve(slothContext.installDir, SLOTH_INTERNAL_PREAMBLE);
+    return readFileSyncWithMessages(filePath, "Error reading internal preamble file at:")
+}
+
+export function readPreamble(preambleFilename) {
+    const filePath = resolve(slothContext.currentDir, preambleFilename);
+    return readFileSyncWithMessages(
+        filePath,
+        "Error reading preamble file at:",
+        "Consider running `gsloth init` to set up your project. Check `gsloth init --help` to see options."
+    )
+}
+
+/**
+ * This function expects https://cli.github.com/ to be installed and authenticated.
+ */
+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.');
+}

package/src/questionAnswering.js

@@ -0,0 +1,68 @@
+import {
+    END,
+    MemorySaver,
+    MessagesAnnotation,
+    START,
+    StateGraph,
+} from "@langchain/langgraph";
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import {initConfig, slothContext} from "./config.js";
+import { display, displayError, displaySuccess } from "./consoleUtils.js";
+import { fileSafeLocalDate, toFileSafeString } from "./utils.js";
+
+await initConfig();
+
+export async function askQuestion(source, preamble, content) {
+    // 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);
+        // 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 };
+    };
+
+    // Define the graph structure with MessagesAnnotation state
+    const workflow = new StateGraph(MessagesAnnotation)
+        // Define the node and edge
+        .addNode("model", callModel)
+        .addEdge(START, "model") // Start at the 'model' node
+        .addEdge("model", END); // End after the 'model' node completes
+
+    // Set up memory (optional but good practice for potential future multi-turn interactions)
+    const memory = new MemorySaver();
+
+    // Compile the workflow into a runnable app
+    const app = workflow.compile({ checkpointer: memory });
+
+    // Construct the initial the messages including the preamble as a system message
+    const messages = [
+        {
+            role: "system",
+            content: preamble, // The preamble goes here
+        },
+        {
+            role: "user",
+            content, // The code diff goes here
+        },
+    ];
+
+    display("Thinking...");
+    const output = await app.invoke({messages}, slothContext.session);
+    // FIXME this looks ugly, there should be other way
+    const outputContent = output.messages[output.messages.length - 1].content;
+    const filePath = path.resolve(process.cwd(), toFileSafeString(source)+'-'+fileSafeLocalDate()+".md");
+    display(`writing ${filePath}`);
+    // TODO highlight LLM output with something like Prism.JS
+    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);
+    }
+}

package/src/utils.js

@@ -0,0 +1,94 @@
+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 {resolve} from "node:path";
+import {spawn} from "node:child_process";
+
+export function toFileSafeString(string) {
+    return string.replace(/[^A-Za-z0-9]/g, '-');
+}
+
+export function fileSafeLocalDate() {
+    const date = new Date();
+    const offsetMs = date.getTimezoneOffset() * 60 * 1000;
+    const msLocal =  date.getTime() - offsetMs;
+    const dateLocal = new Date(msLocal);
+    const iso = dateLocal.toISOString();
+    const isoLocal = iso.slice(0, 19);
+    return toFileSafeString(isoLocal);
+}
+
+export function readFileFromCurrentDir(fileName) {
+    const filePath = resolve(slothContext.currentDir, fileName);
+    display(`Reading file ${fileName}...`);
+    return readFileSyncWithMessages(filePath);
+}
+
+export function writeFileIfNotExistsWithMessages(filePath, content) {
+    display(`checking ${filePath} existence`);
+    if (!existsSync(filePath)) {
+        writeFileSync(filePath, content);
+        displaySuccess(`Created ${filePath}`);
+    } else {
+        displayWarning(`${filePath} already exists`);
+    }
+}
+
+export function readFileSyncWithMessages(filePath, errorMessageIn, noFileMessage) {
+    const errorMessage = errorMessageIn ?? 'Error reading file at: ';
+    try {
+        return readFileSync(filePath, { encoding: 'utf8' });
+    } catch (error) {
+        displayError(errorMessage + filePath);
+        if (error.code === 'ENOENT') {
+            displayWarning(noFileMessage ?? 'Please ensure the file exists.');
+        } else {
+            displayError(error.message);
+        }
+        process.exit(1); // Exit gracefully after error
+    }
+}
+
+export function readStdin(program) {
+    if(process.stdin.isTTY) {
+        program.parse();
+    } else {
+        // Support piping diff into gsloth
+        process.stdout.write('reading STDIN.');
+        process.stdin.on('readable', function() {
+            const chunk = this.read();
+            process.stdout.write('.');
+            if (chunk !== null) {
+                slothContext.stdin += chunk;
+            }
+        });
+        process.stdin.on('end', function() {
+            console.log('');
+            program.parse(process.argv);
+        });
+    }
+}
+
+export async function spawnCommand(command, args, progressMessage, successMessage) {
+    return new Promise((resolve, reject) => {
+        const out = {stdout: ''};
+        const spawned = spawn(command, args);
+        spawned.stdout.on('data', async (stdoutChunk) => {
+            display(progressMessage);
+            out.stdout += stdoutChunk.toString();
+        });
+        spawned.on('error', (err) => {
+            reject(err);
+        })
+        spawned.on('close', (code) => {
+            display(successMessage);
+            resolve(out.stdout);
+        });
+    });
+}
+
+export function getSlothVersion() {
+    const jsonPath = resolve(slothContext.installDir, 'package.json');
+    const projectJson = readFileSync(jsonPath, { encoding: 'utf8' });
+    return JSON.parse(projectJson).version;
+}

package/testMessage.txt

@@ -0,0 +1 @@
+the `dfsdf` is a magic string which fixes our custom transpiler. We should unfortunately use it.