gaunt-sloth-assistant 0.2.2 → 0.3.0

package/src/modules/questionAnsweringModule.ts

@@ -1,14 +1,10 @@
-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 { 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 +18,19 @@ 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
   );
+  progressIndicator.stop();
   const filePath = path.resolve(
     getCurrentDir(),
     toFileSafeString(source) + '-' + fileSafeLocalDate() + '.md'
   );
   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 +42,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);
-}

package/src/modules/reviewModule.ts

@@ -1,23 +1,15 @@
-import type { SlothContext } from '#src/config.js';
 import { slothContext } from '#src/config.js';
 import { display, displayDebug, displayError, displaySuccess } from '#src/consoleUtils.js';
-import type { Message, ProgressCallback, State } from '#src/modules/types.js';
 import { getCurrentDir, stdout } 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 { writeFileSync } from 'node:fs';
 import path from 'node:path';
+import { invoke } from '#src/llmUtils.js';
 
 export async function review(source: string, preamble: string, diff: string): Promise<void> {
   const progressIndicator = new ProgressIndicator('Reviewing.');
-  const outputContent = await reviewInner(
-    slothContext,
-    () => progressIndicator.indicate(),
-    preamble,
-    diff
-  );
+  const outputContent = await invoke(slothContext.config.llm, slothContext.session, preamble, diff);
+  progressIndicator.stop();
   const filePath = path.resolve(
     getCurrentDir(),
     toFileSafeString(source) + '-' + fileSafeLocalDate() + '.md'
@@ -37,45 +29,3 @@ export async function review(source: string, preamble: string, diff: string): Pr
     // exit(1);
   }
 }
-
-export async function reviewInner(
-  context: SlothContext,
-  indicateProgress: ProgressCallback,
-  preamble: string,
-  diff: 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(); // 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: Message[] = [new SystemMessage(preamble), new HumanMessage(diff)];
-
-  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);
-}

package/src/prompt.ts

@@ -1,25 +1,40 @@
-import { resolve } from 'node:path';
-import { GSLOTH_BACKSTORY } from '#src/config.js';
-import { readFileSyncWithMessages, spawnCommand } from '#src/utils.js';
+import {
+  readFileFromCurrentDir,
+  readFileFromCurrentOrInstallDir,
+  spawnCommand,
+} from '#src/utils.js';
 import { displayError } from '#src/consoleUtils.js';
-import { exit, getCurrentDir, getInstallDir } from '#src/systemUtils.js';
+import { exit } from '#src/systemUtils.js';
+import { GSLOTH_BACKSTORY } from '#src/config.js';
 
-export function readInternalPreamble(): string {
-  const installDir = getInstallDir();
-  const filePath = resolve(installDir, GSLOTH_BACKSTORY);
-  return readFileSyncWithMessages(filePath, 'Error reading internal preamble file at:') || '';
+export function readBackstory(): string {
+  return readFileFromCurrentOrInstallDir(GSLOTH_BACKSTORY, true);
 }
 
-export function readPreamble(preambleFilename: string): string {
-  const currentDir = getCurrentDir();
-  const filePath = resolve(currentDir, preambleFilename);
-  return (
-    readFileSyncWithMessages(
-      filePath,
-      'Error reading preamble file at:',
+export function readGuidelines(guidelinesFilename: string): string {
+  try {
+    return readFileFromCurrentDir(guidelinesFilename);
+  } catch (error) {
+    displayError(
       'Consider running `gsloth init` to set up your project. Check `gsloth init --help` to see options.'
-    ) || ''
-  );
+    );
+    throw error;
+  }
+}
+
+export function readReviewInstructions(reviewInstructions: string): string {
+  return readConfigPromptFile(reviewInstructions);
+}
+
+function readConfigPromptFile(guidelinesFilename: string): string {
+  try {
+    return readFileFromCurrentOrInstallDir(guidelinesFilename);
+  } catch (error) {
+    displayError(
+      'Consider running `gsloth init` to set up your project. Check `gsloth init --help` to see options.'
+    );
+    throw error;
+  }
 }
 
 /**

package/src/systemUtils.ts

@@ -1,5 +1,7 @@
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import { ProgressIndicator } from '#src/utils.js';
 
 /**
  * This file contains all system functions and objects that are globally available
@@ -12,10 +14,12 @@ import { fileURLToPath } from 'url';
 
 interface InnerState {
   installDir: string | null | undefined;
+  stringFromStdin: string;
 }
 
 const innerState: InnerState = {
   installDir: undefined,
+  stringFromStdin: '',
 };
 
 // Process-related functions and objects
@@ -26,6 +30,12 @@ export const getInstallDir = (): string => {
   }
   throw new Error('Install directory not set');
 };
+/**
+ * Cached string from stdin. Should only be called after readStdin completes execution.
+ */
+export const getStringFromStdin = (): string => {
+  return innerState.stringFromStdin;
+};
 export const exit = (code?: number): never => process.exit(code || 0);
 export const stdin = process.stdin;
 export const stdout = process.stdout;
@@ -44,6 +54,34 @@ export const setEntryPoint = (indexJs: string): void => {
   innerState.installDir = resolve(dirPath);
 };
 
+/**
+ * Asynchronously reads the stdin and stores it as a string,
+ * it can later be retrieved with getStringFromStdin.
+ */
+export function readStdin(program: Command): Promise<void> {
+  return new Promise((resolvePromise) => {
+    if (stdin.isTTY) {
+      program.parseAsync().then(() => resolvePromise());
+    } else {
+      // Support piping diff into gsloth
+      const progressIndicator = new ProgressIndicator('reading STDIN', true);
+
+      stdin.on('readable', function (this: NodeJS.ReadStream) {
+        const chunk = this.read();
+        progressIndicator.indicate();
+        if (chunk !== null) {
+          const chunkStr = chunk.toString('utf8');
+          innerState.stringFromStdin = innerState.stringFromStdin + chunkStr;
+        }
+      });
+
+      stdin.on('end', function () {
+        program.parseAsync(argv).then(() => resolvePromise());
+      });
+    }
+  });
+}
+
 // Console-related functions
 export const log = (message: string): void => console.log(message);
 export const error = (message: string): void => console.error(message);

package/src/utils.ts

@@ -1,11 +1,10 @@
 import { display, displayError, displaySuccess, displayWarning } from '#src/consoleUtils.js';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { SlothConfig, slothContext } from '#src/config.js';
+import { SlothConfig } from '#src/config.js';
 import { resolve } from 'node:path';
 import { spawn } from 'node:child_process';
-import { exit, stdin, stdout, argv, getCurrentDir, getInstallDir } from '#src/systemUtils.js';
+import { getCurrentDir, getInstallDir, stdout } from '#src/systemUtils.js';
 import url from 'node:url';
-import { Command } from 'commander';
 
 export function toFileSafeString(string: string): string {
   return string.replace(/[^A-Za-z0-9]/g, '-');
@@ -24,10 +23,34 @@ export function fileSafeLocalDate(): string {
 export function readFileFromCurrentDir(fileName: string): string {
   const currentDir = getCurrentDir();
   const filePath = resolve(currentDir, fileName);
-  display(`Reading file ${fileName}...`);
+  display(`Reading file ${filePath}...`);
   return readFileSyncWithMessages(filePath);
 }
 
+export function readFileFromCurrentOrInstallDir(filePath: string, silentCurrent?: boolean): string {
+  const currentDir = getCurrentDir();
+  const currentFilePath = resolve(currentDir, filePath);
+  if (!silentCurrent) {
+    display(`Reading file ${currentFilePath}...`);
+  }
+
+  try {
+    return readFileSync(currentFilePath, { encoding: 'utf8' });
+  } catch (_error) {
+    if (!silentCurrent) {
+      display(`The ${currentFilePath} not found or can\'t be read, trying install directory...`);
+    }
+    const installDir = getInstallDir();
+    const installFilePath = resolve(installDir, filePath);
+    try {
+      return readFileSync(installFilePath, { encoding: 'utf8' });
+    } catch (readFromInstallDirError) {
+      displayError(`The ${installFilePath} not found or can\'t be read.`);
+      throw readFromInstallDirError;
+    }
+  }
+}
+
 export function writeFileIfNotExistsWithMessages(filePath: string, content: string): void {
   display(`checking ${filePath} existence`);
   if (!existsSync(filePath)) {
@@ -53,36 +76,10 @@ export function readFileSyncWithMessages(
     } else {
       displayError((error as Error).message);
     }
-    exit(1); // Exit gracefully after error
-    throw error; // This line will never be reached due to exit(1), but satisfies TypeScript
+    throw error;
   }
 }
 
-export function readStdin(program: Command): Promise<void> {
-  return new Promise((resolvePromise) => {
-    if (stdin.isTTY) {
-      program.parseAsync().then(() => resolvePromise());
-    } else {
-      // Support piping diff into gsloth
-      const progressIndicator = new ProgressIndicator('reading STDIN');
-      progressIndicator.indicate();
-
-      stdin.on('readable', function (this: NodeJS.ReadStream) {
-        const chunk = this.read();
-        progressIndicator.indicate();
-        if (chunk !== null) {
-          const chunkStr = chunk.toString('utf8');
-          (slothContext as { stdin: string }).stdin = slothContext.stdin + chunkStr;
-        }
-      });
-
-      stdin.on('end', function () {
-        program.parseAsync(argv).then(() => resolvePromise());
-      });
-    }
-  });
-}
-
 interface SpawnOutput {
   stdout: string;
   stderr: string;
@@ -95,7 +92,7 @@ export async function spawnCommand(
   successMessage: string
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    const progressIndicator = new ProgressIndicator(progressMessage);
+    const progressIndicator = new ProgressIndicator(progressMessage, true);
     const out: SpawnOutput = { stdout: '', stderr: '' };
     const spawned = spawn(command, args);
 
@@ -134,21 +131,31 @@ export function getSlothVersion(): string {
 }
 
 export class ProgressIndicator {
-  private hasBeenCalled: boolean;
-  private initialMessage: string;
+  private interval: number | undefined = undefined;
 
-  constructor(initialMessage: string) {
-    this.hasBeenCalled = false;
-    this.initialMessage = initialMessage;
+  constructor(initialMessage: string, manual?: boolean) {
+    stdout.write(initialMessage);
+    if (!manual) {
+      this.interval = setInterval(this.indicateInner, 1000) as unknown as number;
+    }
+  }
+
+  private indicateInner(): void {
+    stdout.write('.');
   }
 
   indicate(): void {
-    if (this.hasBeenCalled) {
-      stdout.write('.');
-    } else {
-      this.hasBeenCalled = true;
-      stdout.write(this.initialMessage);
+    if (this.interval) {
+      throw new Error('ProgressIndicator.indicate only to be called in manual mode');
+    }
+    this.indicateInner();
+  }
+
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
     }
+    stdout.write('\n');
   }
 }