gaunt-sloth-assistant 0.1.5 → 0.3.0

package/gth-DIFF-review-2025-05-16T16-18-55.md

@@ -0,0 +1,292 @@
+Okay, let's examine this diff.
+
+## Code Review
+
+### `.gitignore`
+*   `+ /gth-*`
+    *   ✅ **Suggestion:** Adding `gth-*` to `.gitignore` is a good practice if these are generated files (e.g., output from the tool, which seems to be the case with the prefix change from `sloth-*` to `gth-*`). This prevents accidental commits of transient data.
+
+### `.gsloth.guidelines.md` & `.gsloth.review.md`
+*   The changes in `.gsloth.guidelines.md` remove instructions for *me* (the reviewer bot) from the guidelines file.
+*   The new file `.gsloth.review.md` now contains these instructions.
+    *   ✅ **Observation:** This is a sensible refactoring to separate the project's code review guidelines from the instructions for the AI reviewer.
+
+### `README.md` & `docs/CONFIGURATION.md`
+*   `s/.gsloth.preamble.review.md/.gsloth.guidelines.md/g`
+    *   ✅ **Documentation:** The documentation has been updated to reflect the renaming of the primary user-provided guidelines file from `.gsloth.preamble.review.md` to `.gsloth.guidelines.md`. This is consistent with other changes.
+
+### `spec/askCommand.spec.ts`
+*   **Mocking Strategy:**
+    *   The mocking strategy has been changed from using `vi.hoisted()` and a `ctx` object to defining mocks at the top level and using `vi.mock()`.
+        *   ✅ **Suggestion:** This is generally a cleaner and more standard way to handle mocks in Vitest. It improves readability.
+*   **Preamble/Guideline Handling:**
+    *   `ctx.prompt.readInternalPreamble.mockReturnValue('INTERNAL PREAMBLE');` changed to:
+        ```typescript
+        prompt.readBackstory.mockReturnValue('INTERNAL PREAMBLE');
+        prompt.readGuidelines.mockReturnValue('PROJECT GUIDELINES');
+        ```
+    *   The `askQuestion` mock is now expected to be called with a combined preamble: `'INTERNAL PREAMBLE\nPROJECT GUIDELINES'`.
+        *   ✅ **Correctness:** This aligns with the changes in `src/commands/askCommand.ts` where both backstory and project guidelines are now read and combined.
+*   **Output File Prefix:**
+    *   `expect(ctx.questionAnsweringModule.askQuestion).toHaveBeenCalledWith('sloth-ASK', ...)` changed to `expect(askQuestion).toHaveBeenCalledWith('gth-ASK', ...)`.
+        *   ✅ **Correctness:** Reflects the change in the default output file prefix.
+*   **General Test Logic:**
+    *   The tests correctly adapt to the new way preambles are constructed and the new output prefix.
+    *   ✅ **Test Coverage:** The tests cover cases with a message only, with a single file, and with multiple files.
+
+### `spec/config.spec.ts`
+*   **New Default Config Values:**
+    *   Tests now expect `projectGuidelines: '.gsloth.guidelines.md'` and `projectReviewInstructions: '.gsloth.review.md'` in the default configuration.
+        *   ✅ **Correctness:** This is consistent with the introduction of these new configuration options and their default file names.
+*   **Type Safety:**
+    *   The tests for various LLM configurations (`vertexai`, `anthropic`, `groq`) correctly include these new default string properties.
+        *   ✅ **Consistency:** Ensures that all configuration paths are tested with the new defaults.
+
+### `spec/initCommand.spec.ts`
+*   `USER_PROJECT_REVIEW_PREAMBLE: '.gsloth.preamble.review.md'` changed to `USER_PROJECT_REVIEW_PREAMBLE: '.gsloth.guidelines.md'`.
+    *   ✅ **Correctness:** The test mock for `config.js` now uses the updated constant name for the project guidelines file, aligning with the changes in `src/config.ts`.
+
+### `spec/llmUtils.spec.ts`
+*   This is a new test file for the new `src/llmUtils.ts`.
+*   **`invoke` Function Test:**
+    *   It tests the `invoke` function with a `FakeListChatModel`.
+    *   It correctly mocks the `SlothContext` (though it's simplified for this test, which is acceptable for a unit test of `invoke`).
+    *   The test verifies that the `invoke` function returns the content of the first LLM message.
+        *   ⚠️ **Suggestion:** The test for `invoke` is quite basic. It checks if *a* message is returned. It might be beneficial to also assert:
+            *   That the `llm.invoke` method was called with the correct `SystemMessage` and `HumanMessage` constructed from the input `systemMessage` and `prompt`.
+            *   That the `options` (like `configurable: { thread_id: ... }`) are passed through to the LangGraph app invocation.
+            *   If `llm.verbose` is set when `llmGlobalSettings.verbose` is true (though this might be better as a separate test for `setVerbose`'s effect).
+    *   The removal of `SlothContext` type import is fine as the test constructs a minimal context.
+    *   ✅ **Unit Test:** A good starting point for testing the core LLM invocation logic.
+
+### `spec/questionAnsweringModule.spec.ts`
+*   **Refactoring:**
+    *   The test for `askQuestionInner` has been removed, which is correct as this function was inlined/refactored into `llmUtils.invoke`.
+*   **`ProgressIndicator` Mocking:**
+    *   `utilsMock.ProgressIndicator.prototype.stop = vi.fn();`
+    *   `utilsMock.ProgressIndicator.prototype.indicate = vi.fn();`
+        *   ✅ **Correctness:** Mocks the new `stop()` method and the existing `indicate()` method of the `ProgressIndicator`.
+*   **Output File Prefix:**
+    *   `utilsMock.toFileSafeString.mockReturnValue('sloth-ASK');` changed to `utilsMock.toFileSafeString.mockReturnValue('gth-ASK');`.
+    *   `pathMock.resolve` mock adapted accordingly.
+        *   ✅ **Correctness:** Aligns with the prefix change.
+*   **`invoke` Call:**
+    *   The tests now implicitly test the `invoke` function via `askQuestion`.
+*   **Error Handling:**
+    *   The test for file write errors remains and is still relevant.
+    *   ✅ **Test Coverage:** Ensures that `displayError` is called and `ProgressIndicator.stop()` is called in error scenarios.
+
+### `spec/reviewCommand.spec.ts`
+*   **Preamble/Guideline Handling:**
+    *   Mocks for `prompt.readInternalPreamble` and `prompt.readPreamble` are replaced with mocks for `prompt.readBackstory`, `prompt.readGuidelines`, and `prompt.readReviewInstructions`.
+    *   The expected combined preamble string reflects this change: `'INTERNAL BACKSTORY\nPROJECT GUIDELINES\nREVIEW INSTRUCTIONS'`.
+        *   ✅ **Correctness:** Aligns with changes in `src/commands/reviewCommand.ts`.
+*   **Output File Prefix:**
+    *   `sloth-DIFF-review` to `gth-DIFF-review`.
+    *   `sloth-PR-123-review` to `gth-PR-123-review`.
+        *   ✅ **Correctness:** Reflects the prefix change.
+*   **`stdin` Handling:**
+    *   The tests involving `stdin` (e.g., "Should call review with stdin content") have been updated. The way `slothContext` is mocked for these tests has changed slightly (e.g., removing `stdin: ''` from the direct mock of `slothContext` as it's now handled by `systemUtils.getStringFromStdin`).
+        *   ⚠️ **Attention:** The tests for `stdin` now rely on the global `slothContext` from `#src/config.js`. While this works, it makes the tests less isolated. It might be cleaner to mock `getStringFromStdin` from `#src/systemUtils.js` directly within these specific tests if the goal is to unit test the command's logic independent of the `systemUtils` implementation. However, given the current structure, this is functional.
+*   **`SlothContext` Mocking:**
+    *   The way `SlothContext` is constructed for tests involving specific providers (like Jira) has been updated. It now casts a partial `SlothConfig` to `SlothConfig`. This is a common pattern in testing.
+        *   ✅ **Test Setup:** The setup for different content/requirements providers seems correct and adapted to the changes.
+
+### `spec/reviewModule.spec.ts`
+*   **Refactoring:**
+    *   The test for `reviewInner` is removed, consistent with its refactoring.
+*   **New Mocks:**
+    *   Extensive mocking for `fs`, `path`, `systemUtils`, `consoleUtils`, `utils`, and the new `llmUtils`.
+        *   ✅ **Thoroughness:** Good setup for testing the `review` function in isolation.
+*   **`llmUtils.invoke` Mocking:**
+    *   `llmUtilsMock.invoke.mockResolvedValue('LLM Review Response');`
+    *   The test verifies that `llmUtils.invoke` is called with the correct parameters.
+        *   ✅ **Correctness:** This is the primary integration point with the new LLM utility.
+*   **File Operations:**
+    *   Verifies `fs.writeFileSync` is called with the correct path and content.
+    *   Tests error handling for `writeFileSync`.
+        *   ✅ **Robustness:** Covers success and failure paths for file writing.
+*   **`ProgressIndicator`:**
+    *   Verifies `ProgressIndicator.prototype.stop` is called.
+        *   ✅ **Correctness:** Ensures progress indication is properly managed.
+*   **Output File Prefix:**
+    *   `utilsMock.toFileSafeString.mockReturnValue('gth-REVIEW');`
+        *   ✅ **Correctness:** Aligns with prefix change.
+
+### `src/commands/askCommand.ts`
+*   **Preamble/Guideline Reading:**
+    *   `readInternalPreamble()` changed to `readBackstory()` and `readGuidelines(slothContext.config.projectGuidelines)`.
+    *   The preamble is now a combination of these two.
+        *   ✅ **Logic Change:** Correctly implements the new way of constructing the system message for the LLM.
+*   **Output File Prefix:**
+    *   `sloth-ASK` changed to `gth-ASK`.
+    *   `// TODO make the prefix configurable`
+        *   ✅ **Enhancement Noted:** Good that this is marked as a TODO.
+*   **`slothContext` Usage:**
+    *   Uses `slothContext.config.projectGuidelines` to fetch the guidelines file path.
+        *   ✅ **Configuration:** Correctly uses the configured path.
+
+### `src/commands/reviewCommand.ts`
+*   **Preamble/Guideline Reading:**
+    *   Similar to `askCommand`, it now uses `readBackstory()`, `readGuidelines(slothContext.config.projectGuidelines)`, and `readReviewInstructions(slothContext.config.projectReviewInstructions)`.
+        *   ✅ **Logic Change:** Correctly implements the new system message construction.
+*   **`stdin` Handling:**
+    *   `if (context.stdin)` changed to `let stringFromStdin = getStringFromStdin(); if (stringFromStdin)`.
+        *   ✅ **Refactoring:** Uses the new centralized way to get stdin content via `getStringFromStdin` from `systemUtils.ts`. This is a good separation of concerns.
+*   **Output File Prefix:**
+    *   `sloth-DIFF-review` to `gth-DIFF-review`.
+    *   `sloth-PR-${prId}-review` to `gth-PR-${prId}-review`.
+    *   `// TODO make the prefix configurable`
+    *   `// TODO consider including requirements id`
+    *   `// TODO sanitize prId`
+        *   ✅ **Enhancements Noted:** Important TODOs, especially sanitizing `prId` for file system safety.
+*   **`SlothContext` Usage:**
+    *   The command no longer takes `context: SlothContext` as a direct argument to the main action but uses the global `slothContext` for config values. The `program.command().action()` still receives `context` from Commander, but it's not the `SlothContext` we define. This is a subtle but important change. The `reviewCommand` function signature itself still takes `context: SlothContext` but it's the global one.
+        *   ⚠️ **Clarity/Potential Confusion:** The `context` parameter in `reviewCommand(program: Command, context: SlothContext)` refers to the global `slothContext`. Inside the `.action(async (contentId: string | undefined, options: ReviewCommandOptions) => { ... })`, if `context` were used, it would be Commander's context. The code correctly uses the global `slothContext` from import. This is fine, but worth noting the distinction.
+
+### `src/config.ts`
+*   **New Config Properties:**
+    *   `projectGuidelines: string;`
+    *   `projectReviewInstructions: string;`
+        *   ✅ **Feature:** Adds new configurable paths for different types of prompt files.
+*   **Type Change for `llm`:**
+    *   `LanguageModelLike` to `BaseChatModel`.
+        *   ✅ **Type Safety:** `BaseChatModel` is more specific and appropriate for chat-based interactions, which LangChain.js is heavily geared towards. This is a good refinement.
+*   **Removal of `stdin` from `SlothContext`:**
+    *   `stdin: string;` removed.
+        *   ✅ **Refactoring:** `stdin` is now handled by `systemUtils.ts`, which is a better place for system-level input.
+*   **New Constants and Default Values:**
+    *   `PROJECT_GUIDELINES = '.gsloth.guidelines.md';`
+    *   `PROJECT_REVIEW_INSTRUCTIONS = '.gsloth.review.md';`
+    *   `USER_PROJECT_REVIEW_PREAMBLE` constant renamed/replaced by `PROJECT_GUIDELINES`.
+    *   `DEFAULT_CONFIG` updated with these new properties.
+        *   ✅ **Consistency:** All changes align with the new file naming and configuration structure.
+*   **`writeProjectReviewPreamble` function:**
+    *   Now writes to `PROJECT_GUIDELINES` (formerly `USER_PROJECT_REVIEW_PREAMBLE`).
+    *   The default content and warning messages are updated to reflect the new file name.
+        *   ✅ **Correctness:** Updates initialization logic.
+*   **`reset` function:**
+    *   `slothContext.stdin = '';` removed.
+        *   ✅ **Correctness:** Consistent with `stdin` removal from context.
+
+### `src/configs/anthropic.ts` & `src/configs/vertexai.ts`
+*   **Type Change:**
+    *   Return type of `processJsonConfig` changed from `Promise<LanguageModelLike>` to `Promise<BaseChatModel>`.
+        *   ✅ **Type Safety:** Consistent with the type change in `SlothConfig`.
+
+### `src/index.ts`
+*   **New Global Option `--verbose`:**
+    *   `program.option('--verbose', 'Print entire prompt sent to LLM.');`
+    *   `program.parseOptions(argv);`
+    *   `if (program.getOptionValue('verbose')) { setVerbose(true); }`
+        *   ✅ **Feature:** Adds a useful debugging feature. Parsing options before command binding is correct for global options.
+*   **`readStdin` Import:**
+    *   Imported from `systemUtils.js` instead of `utils.js`.
+        *   ✅ **Refactoring:** Correctly reflects the move of this utility.
+
+### `src/llmUtils.ts`
+*   This is a new, crucial file.
+*   **`invoke` function:**
+    *   Uses LangGraph (`StateGraph`, `MessagesAnnotation`, `MemorySaver`, `START`, `END`) to structure the LLM call.
+        *   ✅ **Architecture:** Using LangGraph provides a structured way to manage conversations, even if it's a single turn for now. It allows for easier extension to multi-turn conversations or more complex flows later.
+    *   Constructs `SystemMessage` and `HumanMessage`.
+    *   Handles LLM invocation and extracts the content from the last `AIMessageChunk`.
+    *   `llm.verbose = true;` if `llmGlobalSettings.verbose` is set.
+        *   ✅ **Debugging:** Integrates the verbose option.
+    *   ⚠️ **Error Handling:** The `invoke` function itself doesn't have explicit try-catch blocks for the `app.invoke` call. Errors from the LLM or graph execution would propagate up. This might be acceptable if handled by the callers (`askQuestion`, `review`), which they seem to do for file writing but not explicitly for the LLM call itself (though the `ProgressIndicator` might implicitly handle some visual feedback). Consider if more specific error handling or logging is needed directly within `invoke`.
+    *   ⚠️ **MemorySaver:** `const memory = new MemorySaver();` is created for each `invoke` call. If the `thread_id` in `options` is intended to persist memory across calls *within the same command execution but different logical invocations* (which is not the current pattern but could be a future one), this `MemorySaver` instance would be new each time. For the current single-call-per-command structure, this is fine. If true multi-turn state persistence across separate CLI executions is desired, `MemorySaver` would need to be configured with a persistent checkpointer.
+*   **`setVerbose` function:**
+    *   Sets a global flag for verbose LLM logging.
+        *   ✅ **Utility:** Simple and effective.
+
+### `src/modules/questionAnsweringModule.ts`
+*   **Refactoring:**
+    *   `askQuestionInner` removed.
+    *   Now calls `invoke` from `llmUtils.ts`.
+        *   ✅ **Abstraction:** Good use of the new utility function.
+*   **`ProgressIndicator` Usage:**
+    *   `progressIndicator.stop();` is called after `invoke` completes.
+        *   ✅ **Correctness:** Ensures the indicator is stopped.
+*   **Error Handling:**
+    *   The existing `try-catch` for `writeFileSync` remains. Errors from `invoke` would propagate and potentially lead to an unhandled rejection if not caught by a higher-level mechanism (e.g., Node.js default behavior).
+        *   ⚠️ **Robustness:** While file write errors are handled, consider if errors from the `invoke` call itself (e.g., API errors from the LLM) should be caught and presented more gracefully to the user, perhaps with a specific message before falling into the file write error or generic exit.
+
+### `src/modules/reviewModule.ts`
+*   **Refactoring:**
+    *   `reviewInner` removed.
+    *   Now calls `invoke` from `llmUtils.ts`.
+        *   ✅ **Abstraction:** Good use of the new utility function.
+*   **`ProgressIndicator` Usage:**
+    *   `progressIndicator.stop();` is called after `invoke` completes.
+        *   ✅ **Correctness:** Ensures the indicator is stopped.
+*   **Error Handling:**
+    *   Similar to `questionAnsweringModule`, file write errors are handled. Errors from `invoke` might not be specifically caught here.
+        *   ⚠️ **Robustness:** Same consideration as for `questionAnsweringModule` regarding errors from `invoke`.
+
+### `src/prompt.ts`
+*   **Function Renaming and Logic Changes:**
+    *   `readInternalPreamble` -> `readBackstory`. Now uses `readFileFromCurrentOrInstallDir`.
+    *   `readPreamble` -> `readGuidelines`. Now uses `readFileFromCurrentDir` and has more specific error messaging.
+    *   New `readReviewInstructions` function, uses `readConfigPromptFile` (which is `readFileFromCurrentOrInstallDir`).
+        *   ✅ **Clarity & Flexibility:** The new function names are more descriptive. The use of `readFileFromCurrentOrInstallDir` for `readBackstory` and `readReviewInstructions` allows users to override these if needed, while `readGuidelines` enforces it from the current project directory. This seems like a reasonable design.
+*   **Error Handling:**
+    *   The error messages are more specific and guide the user towards `gsloth init`.
+        *   ✅ **User Experience:** Improved error guidance.
+
+### `src/systemUtils.ts`
+*   **New `getStringFromStdin()`:**
+    *   Returns the cached `innerState.stringFromStdin`.
+        *   ✅ **Utility:** Provides a clean way to access stdin content after it has been read.
+*   **`readStdin()` function:**
+    *   Moved from `utils.ts`.
+    *   Logic updated: `ProgressIndicator` is now instantiated with `manual = true` when reading stdin, and `indicate()` is called inside the `readable` event.
+    *   It now populates `innerState.stringFromStdin` instead of `slothContext.stdin`.
+        *   ✅ **Refactoring & Correctness:** This is a much cleaner way to handle stdin. The progress indication is more accurate. Storing it in `innerState` is good for encapsulation within this module.
+*   **`ProgressIndicator` in `readStdin`:**
+    *   `const progressIndicator = new ProgressIndicator('reading STDIN', true);`
+    *   `progressIndicator.indicate();`
+        *   ⚠️ **Nitpick/Minor:** The `ProgressIndicator` in `readStdin` is not explicitly `stop()`-ed. Since `readStdin` resolves its promise after `program.parseAsync()` which happens on `stdin.on('end')`, the "reading STDIN" message with dots might remain on the screen if other operations are quick. It might be cleaner to call `progressIndicator.stop()` right before `resolvePromise()` in the `end` event handler. However, subsequent output will likely overwrite it, so it's a minor visual point.
+
+### `src/utils.ts`
+*   **Removal of `readStdin`:**
+    *   Correctly removed as it's now in `systemUtils.ts`.
+*   **New `readFileFromCurrentOrInstallDir()`:**
+    *   Tries to read from the current directory first, then falls back to the install directory.
+    *   Includes logging about which path it's trying.
+        *   ✅ **Utility & Robustness:** Useful function for accessing configuration/template files that can be overridden by the user.
+*   **`ProgressIndicator` Class Changes:**
+    *   Constructor now takes an optional `manual` flag. If not manual, it starts an interval timer to print dots.
+    *   `indicate()` method now throws an error if called in non-manual mode.
+    *   New `stop()` method to clear the interval and print a newline.
+        *   ✅ **Enhancement:** This makes the `ProgressIndicator` more versatile. The automatic dot printing is convenient for long-running async tasks where manual indication is cumbersome. The `stop()` method is crucial for cleaning up and ensuring the prompt is clean.
+*   **`spawnCommand` `ProgressIndicator`:**
+    *   `const progressIndicator = new ProgressIndicator(progressMessage, true);`
+    *   The `indicate()` calls within `spawnCommand` are now correct for the manual mode.
+    *   `progressIndicator.stop()` is called in both `close` and `error` handlers.
+        *   ✅ **Correctness:** Proper usage of the updated `ProgressIndicator`.
+
+## Overall Assessment
+
+This is a substantial refactoring and feature addition. The changes are largely positive:
+
+*   **Improved Configuration:** More granular control over prompt files (`.gsloth.guidelines.md`, `.gsloth.review.md`).
+*   **Centralized LLM Logic:** The new `llmUtils.ts` with the `invoke` function using LangGraph is a significant architectural improvement. It centralizes LLM interaction and makes it easier to manage and extend.
+*   **Refined `stdin` Handling:** Moving `stdin` processing to `systemUtils.ts` and caching the result is cleaner.
+*   **Enhanced `ProgressIndicator`:** The utility is now more flexible.
+*   **Code Clarity:** Renaming of functions and constants (e.g., `readBackstory`, `PROJECT_GUIDELINES`) improves readability.
+*   **Type Safety:** Consistent use of `BaseChatModel` is good.
+*   **Test Updates:** Tests have been diligently updated to reflect the changes, and new tests for `llmUtils.ts` and `reviewModule.ts` have been added.
+
+**Minor areas for consideration/improvement:**
+*   More detailed unit tests for `llmUtils.invoke` to assert message construction.
+*   Explicit error handling for LLM API calls within `invoke` or its callers (`reviewModule`, `questionAnsweringModule`) for more user-friendly error messages.
+*   Nitpick about `ProgressIndicator.stop()` in `systemUtils.readStdin`.
+*   The TODOs noted in the code (configurable prefix, sanitizing `prId`) are important for future work.
+
+The developer has demonstrated a good understanding of the LangChain.js/LangGraph.js ecosystem and has applied it effectively. The code quality is high, and the changes are well-reasoned.
+
+## Recommendation
+
+✅ **Approve**
+
+This PR introduces significant improvements to the tool's architecture, configurability, and maintainability. The changes are well-implemented and tested. The minor points raised are suggestions for further refinement rather than blocking issues.

package/index.js

@@ -1,31 +1,14 @@
 #!/usr/bin/env node
-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";
-import {getCurrentDir, getInstallDir, setInstallDir} from "./src/systemUtils.js";
 
-const program = new Command();
+// This is a minimalistic entry point that sets the installDir in systemUtils
+// and delegates to the compiled TypeScript code in dist/index.js
+import { setEntryPoint } from './dist/systemUtils.js';
 
-setInstallDir(dirname(fileURLToPath(import.meta.url)));
-slothContext.currentDir = getCurrentDir();
-slothContext.installDir = getInstallDir();
+// Set the installation directory in systemUtils
+setEntryPoint(import.meta.url);
 
-program
-    .name('gsloth')
-    .description('Gaunt Sloth Assistant reviewing your PRs')
-    .version(getSlothVersion());
-
-initCommand(program, slothContext);
-
-reviewCommand(program, slothContext)
-
-askCommand(program, slothContext);
-
-// TODO add general interactive chat command
-
-await readStdin(program);
+// Import and run the compiled TypeScript code
+import('./dist/index.js').catch((err) => {
+  console.error('Failed to load application:', err);
+  process.exit(1);
+});

package/package.json

@@ -1,41 +1,52 @@
 {
   "name": "gaunt-sloth-assistant",
-  "version": "0.1.5",
+  "version": "0.3.0",
   "description": "",
   "license": "MIT",
   "author": "Andrew Kondratev",
   "type": "module",
-  "main": "index.js",
+  "main": "dist/index.js",
   "repository": "github:andruhon/gaunt-sloth-assistant",
   "engines": {
     "node": ">=22.0.0",
     "npm": ">=10.9.0"
   },
   "scripts": {
-    "test": "jasmine",
-    "lint": "eslint"
+    "build": "tsc",
+    "test": "npm run build &&vitest run",
+    "lint": "eslint . --ext .js,.ts",
+    "format": "prettier --write 'src/**/*.{js,ts}'",
+    "prepare": "npm run build"
   },
   "bin": {
     "gsloth": "index.js",
     "gth": "index.js"
   },
   "dependencies": {
-    "@langchain/anthropic": "^0.3.18",
-    "@langchain/core": "^0.3.45",
-    "@langchain/google-vertexai": "^0.2.4",
+    "@langchain/anthropic": "^0.3.20",
+    "@langchain/core": "^0.3.55",
+    "@langchain/google-vertexai": "^0.2.8",
     "@langchain/groq": "^0.2.2",
-    "@langchain/langgraph": "^0.2.65",
-    "@types/node": "^22.14.1",
+    "@langchain/langgraph": "^0.2.71",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@eslint/js": "^9.25.1",
-    "eslint": "^9.25.1",
-    "eslint-plugin-jasmine": "^4.2.2",
-    "globals": "^16.0.0",
-    "jasmine": "^5.6.0",
-    "testdouble": "^3.20.2"
+    "@eslint/js": "^9.26.0",
+    "@types/node": "^22.15.17",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.32.0",
+    "@typescript-eslint/parser": "^8.32.0",
+    "eslint": "^9.26.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "globals": "^16.1.0",
+    "prettier": "3.5.3",
+    "typescript": "^5.4.2",
+    "vitest": "^3.1.3"
+  },
+  "imports": {
+    "#src/*.js": "./dist/*.js"
   }
 }

package/src/commands/askCommand.ts

@@ -0,0 +1,35 @@
+import { Command } from 'commander';
+import { readBackstory, readGuidelines } from '#src/prompt.js';
+import { readMultipleFilesFromCurrentDir } from '#src/utils.js';
+import { initConfig, slothContext } from '#src/config.js';
+
+interface AskCommandOptions {
+  file?: string[];
+}
+
+/**
+ * Adds the ask command to the program
+ * @param program - The commander program
+ */
+export function askCommand(program: Command): void {
+  program
+    .command('ask')
+    .description('Ask a question')
+    .argument('<message>', 'A message')
+    .option(
+      '-f, --file [files...]',
+      'Input files. Content of these files will be added BEFORE the message'
+    )
+    // TODO add option consuming extra message as argument
+    .action(async (message: string, options: AskCommandOptions) => {
+      const preamble = [readBackstory(), readGuidelines(slothContext.config.projectGuidelines)];
+      const content = [message];
+      if (options.file) {
+        content.push(readMultipleFilesFromCurrentDir(options.file));
+      }
+      await initConfig();
+      const { askQuestion } = await import('#src/modules/questionAnsweringModule.js');
+      // TODO make the prefix configurable
+      await askQuestion('gth-ASK', preamble.join('\n'), content.join('\n'));
+    });
+}

package/src/commands/initCommand.ts

@@ -0,0 +1,19 @@
+import type { ConfigType } from '#src/config.js';
+import { availableDefaultConfigs, createProjectConfig } from '#src/config.js';
+import { Argument, Command } from 'commander';
+
+/**
+ * Adds the init command to the program
+ * @param program - The commander program
+ */
+export function initCommand(program: Command): void {
+  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: ConfigType) => {
+      await createProjectConfig(config);
+    });
+}