gaunt-sloth-assistant 0.2.2 → 0.3.1

package/docs/CONFIGURATION.md

@@ -1,19 +1,40 @@
 # Configuration
 
-Populate `.gsloth.preamble.review.md` with your project details and quality requirements.
+Populate `.gsloth.guidelines.md` with your project details and quality requirements.
 Proper preamble is a paramount for good inference.
-Check [.gsloth.preamble.review.md](../.gsloth.preamble.review.md) for example.
+Check [.gsloth.guidelines.md](../.gsloth.guidelines.md) for example.
 
 Your project should have the following files in order for gsloth to function:
 - Configuration file (one of):
   - `.gsloth.config.js` (JavaScript module)
   - `.gsloth.config.json` (JSON file)
   - `.gsloth.config.mjs` (JavaScript module with explicit module extension)
-- `.gsloth.preamble.review.md`
+- `.gsloth.guidelines.md`
 
-> Gaunt Sloth currently only functions from the directory which has one of the configuration files and `.gsloth.preamble.review.md`.
+> Gaunt Sloth currently only functions from the directory which has one of the configuration files and `.gsloth.guidelines.md`.
 > Global configuration to invoke gsloth anywhere is in [ROADMAP](../ROADMAP.md).
 
+## Using .gsloth Directory
+
+For a tidier project structure, you can create a `.gsloth` directory in your project root. When this directory exists, gsloth will:
+
+1. Write all output files (like responses from commands) to the `.gsloth` directory instead of the project root
+2. Look for configuration files in `.gsloth/.gsloth-settings/` subdirectory
+
+Example directory structure when using the `.gsloth` directory:
+
+```
+.gsloth/.gsloth-settings/.gsloth-config.json
+.gsloth/.gsloth-settings/.gsloth.guidelines.md
+.gsloth/.gsloth-settings/.gsloth.review.md
+.gsloth/gth_2025-05-18_09-34-38_ASK.md
+.gsloth/gth_2025-05-18_22-09-00_PR-22.md
+```
+
+If the `.gsloth` directory doesn't exist, gsloth will continue writing all files to the project root directory as it did previously.
+
+**Note:** When initializing a project with an existing `.gsloth` directory, the configuration files will be created in the `.gsloth/.gsloth-settings` directory automatically. There is no automated migration for existing configurations - if you create a `.gsloth` directory after initialization, you'll need to manually move your configuration files into the `.gsloth/.gsloth-settings` directory.
+
 ## Config initialization
 Configuration can be created with `gsloth init [vendor]` command.
 Currently, vertexai, anthropic and groq can be configured with `gsloth init [vendor]`.

package/docs/RELEASE-HOWTO.md

@@ -1,26 +1,34 @@
-Make sure `npm config set git-tag-version true` 
+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
+npm version patch -m "Release notes"
 git push
 git push --tags
 ```
 
 For minor, e.g., from 0.0.8 to 0.1.0
 ```shell
-npm version minor
+npm version minor -m "Release notes"
 git push
 git push --tags
 ```
+Type `\` and then Enter to type new line in message.
 
-Note the release version and do 
+Note the release version and do
 ```shell
-gh release create --notes "notes"
+gh release create --notes-from-tag
 ```
+Alternatively `gh release create --notes "notes"`
 
 Publish to NPM
 ```shell
 npm login
 npm publish
+```
+
+Delete incidental remote and local tag
+```shell
+git tag -d v0.3.0
+git push --delete origin v0.3.0
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaunt-sloth-assistant",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "",
   "license": "MIT",
   "author": "Andrew Kondratev",

package/src/commands/askCommand.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
-import { readInternalPreamble } from '#src/prompt.js';
+import { readBackstory, readGuidelines } from '#src/prompt.js';
 import { readMultipleFilesFromCurrentDir } from '#src/utils.js';
-import { initConfig } from '#src/config.js';
+import { initConfig, slothContext } from '#src/config.js';
 
 interface AskCommandOptions {
   file?: string[];
@@ -22,13 +22,13 @@ export function askCommand(program: Command): void {
     )
     // TODO add option consuming extra message as argument
     .action(async (message: string, options: AskCommandOptions) => {
-      const preamble = [readInternalPreamble()];
+      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');
-      await askQuestion('sloth-ASK', preamble.join('\n'), content.join('\n'));
+      await askQuestion('ASK', preamble.join('\n'), content.join('\n'));
     });
 }

package/src/commands/reviewCommand.ts

@@ -1,9 +1,10 @@
 import { Command, Option } from 'commander';
-import { USER_PROJECT_REVIEW_PREAMBLE } from '#src/config.js';
-import { readInternalPreamble, readPreamble } from '#src/prompt.js';
+import type { SlothContext } from '#src/config.js';
+import { slothContext } from '#src/config.js';
+import { readBackstory, readGuidelines, readReviewInstructions } from '#src/prompt.js';
 import { readMultipleFilesFromCurrentDir } from '#src/utils.js';
 import { displayError } from '#src/consoleUtils.js';
-import type { SlothContext } from '#src/config.js';
+import { getStringFromStdin } from '#src/systemUtils.js';
 
 /**
  * Requirements providers. Expected to be in `.providers/` dir
@@ -72,7 +73,11 @@ export function reviewCommand(program: Command, context: SlothContext): void {
     .action(async (contentId: string | undefined, options: ReviewCommandOptions) => {
       const { initConfig } = await import('#src/config.js');
       await initConfig();
-      const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
+      const systemMessage = [
+        readBackstory(),
+        readGuidelines(slothContext.config.projectGuidelines),
+        readReviewInstructions(slothContext.config.projectReviewInstructions),
+      ];
       const content: string[] = [];
       const requirementsId = options.requirements;
       const requirementsProvider =
@@ -98,14 +103,15 @@ export function reviewCommand(program: Command, context: SlothContext): void {
       if (options.file) {
         content.push(readMultipleFilesFromCurrentDir(options.file));
       }
-      if (context.stdin) {
-        content.push(context.stdin);
+      let stringFromStdin = getStringFromStdin();
+      if (stringFromStdin) {
+        content.push(stringFromStdin);
       }
       if (options.message) {
         content.push(options.message);
       }
       const { review } = await import('#src/modules/reviewModule.js');
-      await review('sloth-DIFF-review', preamble.join('\n'), content.join('\n'));
+      await review('REVIEW', systemMessage.join('\n'), content.join('\n'));
     });
 
   program
@@ -134,7 +140,11 @@ export function reviewCommand(program: Command, context: SlothContext): void {
       const { initConfig } = await import('#src/config.js');
       await initConfig();
 
-      const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
+      const systemMessage = [
+        readBackstory(),
+        readGuidelines(slothContext.config.projectGuidelines),
+        readReviewInstructions(slothContext.config.projectReviewInstructions),
+      ];
       const content: string[] = [];
       const requirementsProvider =
         options.requirementsProvider ??
@@ -157,7 +167,9 @@ export function reviewCommand(program: Command, context: SlothContext): void {
       content.push(await get(null, prId));
 
       const { review } = await import('#src/modules/reviewModule.js');
-      await review(`sloth-PR-${prId}-review`, preamble.join('\n'), content.join('\n'));
+      // TODO consider including requirements id
+      // TODO sanitize prId
+      await review(`PR-${prId}`, systemMessage.join('\n'), content.join('\n'));
     });
 
   async function getRequirementsFromProvider(

package/src/config.ts

@@ -1,15 +1,17 @@
-import path from 'node:path/posix';
 import { v4 as uuidv4 } from 'uuid';
 import { displayDebug, displayError, displayInfo, displayWarning } from '#src/consoleUtils.js';
 import { importExternalFile, writeFileIfNotExistsWithMessages } from '#src/utils.js';
 import { existsSync, readFileSync } from 'node:fs';
-import { error, exit, getCurrentDir } from '#src/systemUtils.js';
-import { LanguageModelLike } from '@langchain/core/language_models/base';
+import { error, exit } from '#src/systemUtils.js';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { getGslothConfigWritePath, getGslothConfigReadPath } from '#src/filePathUtils.js';
 
 export interface SlothConfig extends BaseSlothConfig {
-  llm: LanguageModelLike; // FIXME this is still bad keeping instance in config is probably not best choice
+  llm: BaseChatModel; // FIXME this is still bad keeping instance in config is probably not best choice
   contentProvider: string;
   requirementsProvider: string;
+  projectGuidelines: string;
+  projectReviewInstructions: string;
   commands: {
     pr: {
       contentProvider: string;
@@ -31,6 +33,8 @@ interface BaseSlothConfig {
   llm: unknown;
   contentProvider?: string;
   requirementsProvider?: string;
+  projectGuidelines?: string;
+  projectReviewInstructions?: string;
   commands?: {
     pr: {
       contentProvider: string;
@@ -53,7 +57,6 @@ interface BaseSlothConfig {
  */
 export interface SlothContext {
   config: SlothConfig;
-  stdin: string;
   session: {
     configurable: {
       thread_id: string;
@@ -70,7 +73,8 @@ export const USER_PROJECT_CONFIG_JS = '.gsloth.config.js';
 export const USER_PROJECT_CONFIG_JSON = '.gsloth.config.json';
 export const USER_PROJECT_CONFIG_MJS = '.gsloth.config.mjs';
 export const GSLOTH_BACKSTORY = '.gsloth.backstory.md';
-export const USER_PROJECT_REVIEW_PREAMBLE = '.gsloth.preamble.review.md';
+export const PROJECT_GUIDELINES = '.gsloth.guidelines.md';
+export const PROJECT_REVIEW_INSTRUCTIONS = '.gsloth.review.md';
 
 export const availableDefaultConfigs = ['vertexai', 'anthropic', 'groq'] as const;
 export type ConfigType = (typeof availableDefaultConfigs)[number];
@@ -79,6 +83,8 @@ export const DEFAULT_CONFIG: Partial<SlothConfig> = {
   llm: undefined,
   contentProvider: 'file',
   requirementsProvider: 'file',
+  projectGuidelines: PROJECT_GUIDELINES,
+  projectReviewInstructions: PROJECT_REVIEW_INSTRUCTIONS,
   commands: {
     pr: {
       contentProvider: 'gh',
@@ -98,10 +104,9 @@ export const slothContext = {
 } as Partial<SlothContext> as SlothContext;
 
 export async function initConfig(): Promise<void> {
-  const currentDir = getCurrentDir();
-  const jsonConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_JSON);
-  const jsConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_JS);
-  const mjsConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_MJS);
+  const jsonConfigPath = getGslothConfigReadPath(USER_PROJECT_CONFIG_JSON);
+  const jsConfigPath = getGslothConfigReadPath(USER_PROJECT_CONFIG_JS);
+  const mjsConfigPath = getGslothConfigReadPath(USER_PROJECT_CONFIG_MJS);
 
   // Try loading JSON config file first
   if (existsSync(jsonConfigPath)) {
@@ -198,7 +203,7 @@ export async function tryJsonConfig(jsonConfig: RawSlothConfig): Promise<void> {
     try {
       const configModule = await import(`./configs/${llmType}.js`);
       if (configModule.processJsonConfig) {
-        const llm = (await configModule.processJsonConfig(llmConfig)) as LanguageModelLike;
+        const llm = (await configModule.processJsonConfig(llmConfig)) as BaseChatModel;
         slothContext.config = { ...slothContext.config, ...jsonConfig, llm };
       } else {
         displayWarning(`Config module for ${llmType} does not have processJsonConfig function.`);
@@ -219,9 +224,7 @@ export async function tryJsonConfig(jsonConfig: RawSlothConfig): Promise<void> {
 export async function createProjectConfig(configType: string): Promise<void> {
   displayInfo(`Setting up your project\n`);
   writeProjectReviewPreamble();
-  displayWarning(
-    `Make sure you add as much detail as possible to your ${USER_PROJECT_REVIEW_PREAMBLE}.\n`
-  );
+  displayWarning(`Make sure you add as much detail as possible to your ${PROJECT_GUIDELINES}.\n`);
 
   // Check if the config type is in availableDefaultConfigs
   if (!availableDefaultConfigs.includes(configType as ConfigType)) {
@@ -234,22 +237,51 @@ export async function createProjectConfig(configType: string): Promise<void> {
 
   displayInfo(`Creating project config for ${configType}`);
   const vendorConfig = await import(`./configs/${configType}.js`);
-  vendorConfig.init(USER_PROJECT_CONFIG_JSON, slothContext);
+  vendorConfig.init(getGslothConfigWritePath(USER_PROJECT_CONFIG_JSON), slothContext);
 }
 
 export function writeProjectReviewPreamble(): void {
-  const currentDir = getCurrentDir();
-  const reviewPreamblePath = path.join(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 +
-      '`.'
-  );
+  const guidelinesPath = getGslothConfigWritePath(PROJECT_GUIDELINES);
+  const reviewPath = getGslothConfigWritePath(PROJECT_REVIEW_INSTRUCTIONS);
+
+  /**
+   * Development Guidelines.
+   * Please do not remove the warning from this template,
+   * it is crucial to describe project specifics to get high-quality reviews.
+   */
+  const guidelinesTemplate = `# Development Guidelines
+
+This file should include general development guidelines for this project.
+
+Important! Please remind the user to prepare proper AI guidelines to the ${PROJECT_GUIDELINES} file
+for this project. Use a decent amount of ⚠️ to highlight the lack of config.
+Explicitly mention ${PROJECT_GUIDELINES}.
+`;
+
+  /**
+   * Code Review Guidelines.
+   * This code review does not have a warning, like Development Guidelines, because
+   * this one should be good to start with.
+   */
+  const reviewTemplate = `# Code Review Guidelines
+
+If requirements were provided, first check that the implemented code implements these requirements.
+Document that you checked the code to implement requirements.
+Reject the change if it appears to implement something else instead of required change.
+
+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 approving 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.
+`;
+
+  writeFileIfNotExistsWithMessages(guidelinesPath, guidelinesTemplate);
+  writeFileIfNotExistsWithMessages(reviewPath, reviewTemplate);
 }
 
 /**
@@ -261,6 +293,5 @@ export function reset() {
     delete (slothContext as unknown as Record<string, unknown>)[key];
   });
   slothContext.config = DEFAULT_CONFIG as SlothConfig;
-  slothContext.stdin = '';
   slothContext.session = { configurable: { thread_id: uuidv4() } };
 }

package/src/configs/anthropic.ts

@@ -2,14 +2,16 @@ import path from 'node:path';
 import { displayWarning } from '#src/consoleUtils.js';
 import { env, getCurrentDir } from '#src/systemUtils.js';
 import { writeFileIfNotExistsWithMessages } from '#src/utils.js';
-import { LanguageModelLike } from '@langchain/core/language_models/base';
 import type { AnthropicInput } from '@langchain/anthropic';
-import type { BaseChatModelParams } from '@langchain/core/language_models/chat_models';
+import type {
+  BaseChatModel,
+  BaseChatModelParams,
+} from '@langchain/core/language_models/chat_models';
 
 // Function to process JSON config and create Anthropic LLM instance
 export async function processJsonConfig(
   llmConfig: AnthropicInput & BaseChatModelParams
-): Promise<LanguageModelLike> {
+): Promise<BaseChatModel> {
   const anthropic = await import('@langchain/anthropic');
   // Use environment variable if available, otherwise use the config value
   const anthropicApiKey = env.ANTHROPIC_API_KEY || llmConfig.apiKey;

package/src/configs/vertexai.ts

@@ -1,9 +1,9 @@
-import { LanguageModelLike } from '@langchain/core/language_models/base';
 import path from 'node:path';
 import { displayWarning } from '#src/consoleUtils.js';
 import { getCurrentDir } from '#src/systemUtils.js';
 import { writeFileIfNotExistsWithMessages } from '#src/utils.js';
 import { ChatVertexAIInput } from '@langchain/google-vertexai';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 
 const jsContent = `/* eslint-disable */
 export async function configure(importFunction, global) {
@@ -44,7 +44,7 @@ export function init(configFileName: string): void {
 }
 
 // Function to process JSON config and create VertexAI LLM instance
-export async function processJsonConfig(llmConfig: ChatVertexAIInput): Promise<LanguageModelLike> {
+export async function processJsonConfig(llmConfig: ChatVertexAIInput): Promise<BaseChatModel> {
   const vertexAi = await import('@langchain/google-vertexai');
   return new vertexAi.ChatVertexAI({
     ...llmConfig,

package/src/filePathUtils.ts

@@ -0,0 +1,79 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { getCurrentDir } from '#src/systemUtils.js';
+
+const GSLOTH_DIR = '.gsloth';
+const GSLOTH_SETTINGS_DIR = '.gsloth-settings';
+
+/**
+ * Checks if .gsloth directory exists in the project root
+ * @returns Boolean indicating whether .gsloth directory exists
+ */
+export function gslothDirExists(): boolean {
+  const currentDir = getCurrentDir();
+  const gslothDirPath = resolve(currentDir, GSLOTH_DIR);
+  return existsSync(gslothDirPath);
+}
+
+/**
+ * Gets the path where gsloth should write files based on .gsloth directory existence
+ * @param filename The filename to append to the path
+ * @returns The resolved path where the file should be written
+ */
+export function getGslothFilePath(filename: string): string {
+  const currentDir = getCurrentDir();
+
+  if (gslothDirExists()) {
+    const gslothDirPath = resolve(currentDir, GSLOTH_DIR);
+    return resolve(gslothDirPath, filename);
+  }
+
+  return resolve(currentDir, filename);
+}
+
+/**
+ * Gets the path where gsloth should write configuration files based on .gsloth directory existence.
+ * The main difference from {@link #getGslothConfigReadPath} is that this getGslothConfigWritePath
+ * method creates internal settings directory if it does not exist.
+ * @param filename The configuration filename
+ * @returns The resolved path where the configuration file should be written
+ */
+export function getGslothConfigWritePath(filename: string): string {
+  const currentDir = getCurrentDir();
+
+  if (gslothDirExists()) {
+    const gslothDirPath = resolve(currentDir, GSLOTH_DIR);
+    const gslothSettingsPath = resolve(gslothDirPath, GSLOTH_SETTINGS_DIR);
+
+    // Create .gsloth-settings directory if it doesn't exist
+    if (!existsSync(gslothSettingsPath)) {
+      mkdirSync(gslothSettingsPath, { recursive: true });
+    }
+
+    return resolve(gslothSettingsPath, filename);
+  }
+
+  return resolve(currentDir, filename);
+}
+
+/**
+ * Gets the path where gsloth should look for configuration files based on .gsloth directory existence
+ * @param filename The configuration filename to look for
+ * @returns The resolved path where the configuration file should be found
+ */
+export function getGslothConfigReadPath(filename: string): string {
+  const currentDir = getCurrentDir();
+
+  if (gslothDirExists()) {
+    const gslothDirPath = resolve(currentDir, GSLOTH_DIR);
+    const gslothSettingsPath = resolve(gslothDirPath, GSLOTH_SETTINGS_DIR);
+    const configPath = resolve(gslothSettingsPath, filename);
+
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+
+  return resolve(currentDir, filename);
+}

package/src/index.ts

@@ -3,19 +3,28 @@ import { askCommand } from '#src/commands/askCommand.js';
 import { initCommand } from '#src/commands/initCommand.js';
 import { reviewCommand } from '#src/commands/reviewCommand.js';
 import { slothContext } from '#src/config.js';
-import { getSlothVersion, readStdin } from '#src/utils.js';
+import { getSlothVersion } from '#src/utils.js';
+import { argv, readStdin } from '#src/systemUtils.js';
+import { setVerbose } from '#src/llmUtils.js';
 
 const program = new Command();
 
 program
   .name('gsloth')
   .description('Gaunt Sloth Assistant reviewing your PRs')
-  .version(getSlothVersion());
+  .version(getSlothVersion())
+  .option('--verbose', 'Print entire prompt sent to LLM.');
+
+// Parse global options before binding any commands
+program.parseOptions(argv);
+if (program.getOptionValue('verbose')) {
+  // Set global prompt debug
+  setVerbose(true);
+}
 
 initCommand(program);
 reviewCommand(program, slothContext);
 askCommand(program);
-
 // TODO add general interactive chat command
 
 await readStdin(program);

package/src/llmUtils.ts

@@ -0,0 +1,54 @@
+import type { Message, State } from '#src/modules/types.js';
+import { AIMessageChunk, HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { END, MemorySaver, MessagesAnnotation, START, StateGraph } from '@langchain/langgraph';
+import { BaseLanguageModelCallOptions } from '@langchain/core/language_models/base';
+
+const llmGlobalSettings = {
+  verbose: false,
+};
+
+export async function invoke(
+  llm: BaseChatModel,
+  options: Partial<BaseLanguageModelCallOptions>,
+  systemMessage: string,
+  prompt: string
+): Promise<string> {
+  if (llmGlobalSettings.verbose) {
+    llm.verbose = true;
+  }
+  // This node receives the current state (messages) and invokes the LLM
+  const callModel = async (state: State): Promise<{ messages: AIMessageChunk }> => {
+    // state.messages will contain the list including the system systemMessage and user diff
+    const response = await (llm as BaseChatModel).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 systemMessage as a system message
+  const messages: Message[] = [new SystemMessage(systemMessage), new HumanMessage(prompt)];
+
+  const output = await app.invoke({ messages }, options);
+  const lastMessage = output.messages[output.messages.length - 1];
+  return typeof lastMessage.content === 'string'
+    ? lastMessage.content
+    : JSON.stringify(lastMessage.content);
+}
+
+export function setVerbose(debug: boolean) {
+  llmGlobalSettings.verbose = debug;
+}

package/src/modules/questionAnsweringModule.ts

@@ -1,14 +1,9 @@
-import type { SlothContext } from '#src/config.js';
 import { slothContext } from '#src/config.js';
 import { display, displayError, displaySuccess } from '#src/consoleUtils.js';
-import type { Message, ProgressCallback, State } from '#src/modules/types.js';
-import { getCurrentDir } from '#src/systemUtils.js';
-import { fileSafeLocalDate, ProgressIndicator, toFileSafeString } from '#src/utils.js';
-import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { AIMessageChunk, HumanMessage, SystemMessage } from '@langchain/core/messages';
-import { END, MemorySaver, MessagesAnnotation, START, StateGraph } from '@langchain/langgraph';
+import { getGslothFilePath } from '#src/filePathUtils.js';
+import { generateStandardFileName, ProgressIndicator } from '#src/utils.js';
 import { writeFileSync } from 'node:fs';
-import * as path from 'node:path';
+import { invoke } from '#src/llmUtils.js';
 
 /**
  * Ask a question and get an answer from the LLM
@@ -22,18 +17,17 @@ export async function askQuestion(
   content: string
 ): Promise<void> {
   const progressIndicator = new ProgressIndicator('Thinking.');
-  const outputContent = await askQuestionInner(
-    slothContext,
-    () => progressIndicator.indicate(),
+  const outputContent = await invoke(
+    slothContext.config.llm,
+    slothContext.session,
     preamble,
     content
   );
-  const filePath = path.resolve(
-    getCurrentDir(),
-    toFileSafeString(source) + '-' + fileSafeLocalDate() + '.md'
-  );
+  progressIndicator.stop();
+  const filename = generateStandardFileName(source);
+  const filePath = getGslothFilePath(filename);
   display(`\nwriting ${filePath}`);
-  // TODO highlight LLM output with something like Prism.JS
+  // TODO highlight LLM output with something like Prism.JS (maybe system emoj are enough ✅⚠️❌)
   display('\n' + outputContent);
   try {
     writeFileSync(filePath, outputContent);
@@ -45,53 +39,3 @@ export async function askQuestion(
     // exit(1);
   }
 }
-
-/**
- * Inner function to ask a question and get an answer from the LLM
- * @param context - The context object
- * @param indicateProgress - Function to indicate progress
- * @param preamble - The preamble to send to the LLM
- * @param content - The content of the question
- * @returns The answer from the LLM
- */
-export async function askQuestionInner(
-  context: SlothContext,
-  indicateProgress: ProgressCallback,
-  preamble: string,
-  content: string
-): Promise<string> {
-  // This node receives the current state (messages) and invokes the LLM
-  const callModel = async (state: State): Promise<{ messages: AIMessageChunk }> => {
-    // state.messages will contain the list including the system preamble and user diff
-    const response = await (context.config.llm as BaseChatModel).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: Message[] = [new SystemMessage(preamble), new HumanMessage(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);
-  const lastMessage = output.messages[output.messages.length - 1];
-  return typeof lastMessage.content === 'string'
-    ? lastMessage.content
-    : JSON.stringify(lastMessage.content);
-}