gaunt-sloth-assistant 0.1.4 → 0.2.2

package/src/config.ts

@@ -0,0 +1,266 @@
+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';
+
+export interface SlothConfig extends BaseSlothConfig {
+  llm: LanguageModelLike; // FIXME this is still bad keeping instance in config is probably not best choice
+  contentProvider: string;
+  requirementsProvider: string;
+  commands: {
+    pr: {
+      contentProvider: string;
+    };
+  };
+}
+
+/**
+ * Raw, unprocessed sloth config
+ */
+export interface RawSlothConfig extends BaseSlothConfig {
+  llm: LLMConfig;
+}
+
+/**
+ * Do not export this one
+ */
+interface BaseSlothConfig {
+  llm: unknown;
+  contentProvider?: string;
+  requirementsProvider?: string;
+  commands?: {
+    pr: {
+      contentProvider: string;
+    };
+  };
+  review?: {
+    requirementsProvider?: string;
+    contentProvider?: string;
+  };
+  pr?: {
+    requirementsProvider?: string;
+  };
+  requirementsProviderConfig?: Record<string, unknown>;
+  contentProviderConfig?: Record<string, unknown>;
+}
+
+/**
+ * @deprecated
+ * this object has blurred responsibility lines and bad name.
+ */
+export interface SlothContext {
+  config: SlothConfig;
+  stdin: string;
+  session: {
+    configurable: {
+      thread_id: string;
+    };
+  };
+}
+
+export interface LLMConfig extends Record<string, unknown> {
+  type: string;
+  model: string;
+}
+
+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 availableDefaultConfigs = ['vertexai', 'anthropic', 'groq'] as const;
+export type ConfigType = (typeof availableDefaultConfigs)[number];
+
+export const DEFAULT_CONFIG: Partial<SlothConfig> = {
+  llm: undefined,
+  contentProvider: 'file',
+  requirementsProvider: 'file',
+  commands: {
+    pr: {
+      contentProvider: 'gh',
+    },
+  },
+};
+
+/**
+ * @deprecated
+ * this object has blurred responsibility lines and bad name.
+ * TODO this should be reworked to something more robust
+ */
+export const slothContext = {
+  config: DEFAULT_CONFIG,
+  stdin: '',
+  session: { configurable: { thread_id: uuidv4() } },
+} 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);
+
+  // Try loading JSON config file first
+  if (existsSync(jsonConfigPath)) {
+    try {
+      const jsonConfig = JSON.parse(readFileSync(jsonConfigPath, 'utf8')) as RawSlothConfig;
+      // If the config has an LLM with a type, create the appropriate LLM instance
+      if (jsonConfig.llm && typeof jsonConfig.llm === 'object' && 'type' in jsonConfig.llm) {
+        await tryJsonConfig(jsonConfig);
+      } else {
+        error(`${jsonConfigPath} is not in valid format. Should at least define llm.type`);
+        exit(1);
+      }
+    } catch (e) {
+      displayDebug(e instanceof Error ? e : String(e));
+      displayError(
+        `Failed to read config from ${USER_PROJECT_CONFIG_JSON}, will try other formats.`
+      );
+      // Continue to try other formats
+      return tryJsConfig();
+    }
+  } else {
+    // JSON config not found, try JS
+    return tryJsConfig();
+  }
+
+  // Helper function to try loading JS config
+  async function tryJsConfig(): Promise<void> {
+    if (existsSync(jsConfigPath)) {
+      return importExternalFile(jsConfigPath)
+        .then((i: { configure: (module: string) => Promise<Partial<SlothConfig>> }) =>
+          i.configure(jsConfigPath)
+        )
+        .then((config) => {
+          slothContext.config = { ...slothContext.config, ...config };
+        })
+        .catch((e) => {
+          displayDebug(e instanceof Error ? e : String(e));
+          displayError(
+            `Failed to read config from ${USER_PROJECT_CONFIG_JS}, will try other formats.`
+          );
+          // Continue to try other formats
+          return tryMjsConfig();
+        });
+    } else {
+      // JS config not found, try MJS
+      return tryMjsConfig();
+    }
+  }
+
+  // Helper function to try loading MJS config
+  async function tryMjsConfig(): Promise<void> {
+    if (existsSync(mjsConfigPath)) {
+      return importExternalFile(mjsConfigPath)
+        .then((i: { configure: (module: string) => Promise<Partial<SlothConfig>> }) =>
+          i.configure(mjsConfigPath)
+        )
+        .then((config) => {
+          slothContext.config = { ...slothContext.config, ...config };
+        })
+        .catch((e) => {
+          displayDebug(e instanceof Error ? e : String(e));
+          displayError(`Failed to read config from ${USER_PROJECT_CONFIG_MJS}.`);
+          displayError(`No valid configuration found. Please create a valid configuration file.`);
+          exit();
+        });
+    } else {
+      // No config files found
+      displayError(
+        'No configuration file found. Please create one of: ' +
+          `${USER_PROJECT_CONFIG_JSON}, ${USER_PROJECT_CONFIG_JS}, or ${USER_PROJECT_CONFIG_MJS} ` +
+          'in your project directory.'
+      );
+      exit();
+    }
+  }
+}
+
+// Process JSON LLM config by creating the appropriate LLM instance
+export async function tryJsonConfig(jsonConfig: RawSlothConfig): Promise<void> {
+  const llmConfig = jsonConfig?.llm;
+  const llmType = llmConfig?.type?.toLowerCase();
+
+  // Check if the LLM type is in availableDefaultConfigs
+  if (!llmType || !availableDefaultConfigs.includes(llmType as ConfigType)) {
+    displayError(
+      `Unsupported LLM type: ${llmType}. Available types are: ${availableDefaultConfigs.join(', ')}`
+    );
+    exit(1);
+    return;
+  }
+
+  try {
+    // Import the appropriate config module based on the LLM type
+    try {
+      const configModule = await import(`./configs/${llmType}.js`);
+      if (configModule.processJsonConfig) {
+        const llm = (await configModule.processJsonConfig(llmConfig)) as LanguageModelLike;
+        slothContext.config = { ...slothContext.config, ...jsonConfig, llm };
+      } else {
+        displayWarning(`Config module for ${llmType} does not have processJsonConfig function.`);
+        exit(1);
+      }
+    } catch (importError) {
+      displayDebug(importError instanceof Error ? importError : String(importError));
+      displayWarning(`Could not import config module for ${llmType}.`);
+      exit(1);
+    }
+  } catch (error) {
+    displayDebug(error instanceof Error ? error : String(error));
+    displayError(`Error creating LLM instance for type ${llmType}.`);
+    exit(1);
+  }
+}
+
+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`
+  );
+
+  // Check if the config type is in availableDefaultConfigs
+  if (!availableDefaultConfigs.includes(configType as ConfigType)) {
+    displayError(
+      `Unsupported config type: ${configType}. Available types are: ${availableDefaultConfigs.join(', ')}`
+    );
+    exit(1);
+    return;
+  }
+
+  displayInfo(`Creating project config for ${configType}`);
+  const vendorConfig = await import(`./configs/${configType}.js`);
+  vendorConfig.init(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 +
+      '`.'
+  );
+}
+
+/**
+ * @deprecated test only
+ * TODO should be gone together with slothContext itself
+ */
+export function reset() {
+  Object.keys(slothContext).forEach((key) => {
+    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

@@ -0,0 +1,55 @@
+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';
+
+// Function to process JSON config and create Anthropic LLM instance
+export async function processJsonConfig(
+  llmConfig: AnthropicInput & BaseChatModelParams
+): Promise<LanguageModelLike> {
+  const anthropic = await import('@langchain/anthropic');
+  // Use environment variable if available, otherwise use the config value
+  const anthropicApiKey = env.ANTHROPIC_API_KEY || llmConfig.apiKey;
+  return new anthropic.ChatAnthropic({
+    ...llmConfig,
+    apiKey: anthropicApiKey,
+    model: llmConfig.model || 'claude-3-7-sonnet-20250219',
+  });
+}
+
+const jsContent = `/* 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: process.env.ANTHROPIC_API_KEY, // Default value, but you can provide the key in many different ways, even as literal
+            model: "claude-3-7-sonnet-20250219" // Don't forget to check new models availability.
+        })
+    };
+}
+`;
+
+const jsonContent = `{
+  "llm": {
+    "type": "anthropic",
+    "apiKey": "your-api-key-here",
+    "model": "claude-3-7-sonnet-20250219"
+  }
+}`;
+
+export function init(configFileName: string): void {
+  const currentDir = getCurrentDir();
+  path.join(currentDir, configFileName);
+
+  // Determine which content to use based on file extension
+  const content = configFileName.endsWith('.json') ? jsonContent : jsContent;
+
+  writeFileIfNotExistsWithMessages(configFileName, content);
+  displayWarning(`You need to update your ${configFileName} to add your Anthropic API key.`);
+}

package/src/configs/fake.ts

@@ -0,0 +1,15 @@
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { displayWarning } from '#src/consoleUtils.js';
+import type { FakeChatInput } from '@langchain/core/utils/testing';
+
+// Function to process JSON config and create Fake LLM instance for testing
+export async function processJsonConfig(llmConfig: FakeChatInput): Promise<BaseChatModel | null> {
+  if (llmConfig.responses) {
+    const test = await import('@langchain/core/utils/testing');
+    return new test.FakeListChatModel(llmConfig);
+  }
+  displayWarning("Fake LLM requires 'responses' array in config");
+  return null;
+}
+
+// No init function needed for fake LLM as it's only used for testing

package/src/configs/groq.ts

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import { displayInfo, displayWarning } from '#src/consoleUtils.js';
+import { env, getCurrentDir } from '#src/systemUtils.js';
+import { writeFileIfNotExistsWithMessages } from '#src/utils.js';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { ChatGroqInput } from '@langchain/groq';
+
+// Function to process JSON config and create Groq LLM instance
+export async function processJsonConfig(llmConfig: ChatGroqInput): Promise<BaseChatModel> {
+  const groq = await import('@langchain/groq');
+  // Use environment variable if available, otherwise use the config value
+  const groqApiKey = env.GROQ_API_KEY || llmConfig.apiKey;
+  return new groq.ChatGroq({
+    ...llmConfig,
+    apiKey: groqApiKey,
+    model: llmConfig.model || 'deepseek-r1-distill-llama-70b',
+  });
+}
+
+const jsContent = `/* eslint-disable */
+export async function configure(importFunction, global) {
+    // this is going to be imported from sloth dependencies,
+    // but can potentially be pulled from global node modules or from this project
+    const groq = await importFunction('@langchain/groq');
+    return {
+        llm: new groq.ChatGroq({
+            model: "deepseek-r1-distill-llama-70b", // Check other models available
+            apiKey: process.env.GROQ_API_KEY, // Default value, but you can provide the key in many different ways, even as literal
+        })
+    };
+}
+`;
+
+const jsonContent = `{
+  "llm": {
+    "type": "groq",
+    "model": "deepseek-r1-distill-llama-70b",
+    "apiKey": "your-api-key-here"
+  }
+}`;
+
+export function init(configFileName: string): void {
+  const currentDir = getCurrentDir();
+  path.join(currentDir, configFileName);
+
+  // Determine which content to use based on file extension
+  const content = configFileName.endsWith('.json') ? jsonContent : jsContent;
+
+  writeFileIfNotExistsWithMessages(configFileName, content);
+  displayInfo(
+    `You can define GROQ_API_KEY environment variable with your Groq API key and it will work with default model.`
+  );
+  displayWarning(`You need to edit your ${configFileName} to configure model.`);
+}

package/src/configs/vertexai.ts

@@ -0,0 +1,53 @@
+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';
+
+const jsContent = `/* 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-preview-05-06", // 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
+            // project: 'your-cool-gcloud-project'
+        })
+    }
+}
+`;
+
+const jsonContent = `{
+  "llm": {
+    "type": "vertexai",
+    "model": "gemini-2.5-pro-preview-05-06",
+    "temperature": 0
+  }
+}`;
+
+export function init(configFileName: string): void {
+  const currentDir = getCurrentDir();
+  path.join(currentDir, configFileName);
+
+  // Determine which content to use based on file extension
+  const content = configFileName.endsWith('.json') ? jsonContent : jsContent;
+
+  writeFileIfNotExistsWithMessages(configFileName, content);
+  displayWarning(
+    'For Google VertexAI you likely to need to do `gcloud auth login` and `gcloud auth application-default login`.'
+  );
+}
+
+// Function to process JSON config and create VertexAI LLM instance
+export async function processJsonConfig(llmConfig: ChatVertexAIInput): Promise<LanguageModelLike> {
+  const vertexAi = await import('@langchain/google-vertexai');
+  return new vertexAi.ChatVertexAI({
+    ...llmConfig,
+    model: llmConfig.model || 'gemini-2.5-pro-preview-05-06',
+  });
+}

package/src/consoleUtils.ts

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { debug as systemDebug, error as systemError, log } from '#src/systemUtils.js';
+
+// TODO it seems like commander supports coloured output, maybe dependency to chalk can be removed
+
+export function displayError(message: string): void {
+  systemError(chalk.red(message));
+}
+
+export function displayWarning(message: string): void {
+  systemError(chalk.yellow(message));
+}
+
+export function displaySuccess(message: string): void {
+  systemError(chalk.green(message));
+}
+
+export function displayInfo(message: string): void {
+  systemError(chalk.blue(message));
+}
+
+export function display(message: string): void {
+  log(message);
+}
+
+export function displayDebug(message: string | Error | undefined): void {
+  // TODO make it controlled by config
+  if (message instanceof Error) {
+    systemDebug(message.stack || '');
+  } else if (message !== undefined) {
+    systemDebug(message);
+  }
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+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';
+
+const program = new Command();
+
+program
+  .name('gsloth')
+  .description('Gaunt Sloth Assistant reviewing your PRs')
+  .version(getSlothVersion());
+
+initCommand(program);
+reviewCommand(program, slothContext);
+askCommand(program);
+
+// TODO add general interactive chat command
+
+await readStdin(program);

package/src/modules/questionAnsweringModule.ts

@@ -0,0 +1,97 @@
+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';
+
+/**
+ * Ask a question and get an answer from the LLM
+ * @param source - The source of the question (used for file naming)
+ * @param preamble - The preamble to send to the LLM
+ * @param content - The content of the question
+ */
+export async function askQuestion(
+  source: string,
+  preamble: string,
+  content: string
+): Promise<void> {
+  const progressIndicator = new ProgressIndicator('Thinking.');
+  const outputContent = await askQuestionInner(
+    slothContext,
+    () => progressIndicator.indicate(),
+    preamble,
+    content
+  );
+  const filePath = path.resolve(
+    getCurrentDir(),
+    toFileSafeString(source) + '-' + fileSafeLocalDate() + '.md'
+  );
+  display(`\nwriting ${filePath}`);
+  // TODO highlight LLM output with something like Prism.JS
+  display('\n' + outputContent);
+  try {
+    writeFileSync(filePath, outputContent);
+    displaySuccess(`This report can be found in ${filePath}`);
+  } catch (error) {
+    displayError(`Failed to write answer to file: ${filePath}`);
+    displayError(error instanceof Error ? error.message : String(error));
+    // TODO Consider if we want to exit or just log the error
+    // 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

@@ -0,0 +1,81 @@
+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';
+
+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 filePath = path.resolve(
+    getCurrentDir(),
+    toFileSafeString(source) + '-' + fileSafeLocalDate() + '.md'
+  );
+  stdout.write('\n');
+  display(`writing ${filePath}`);
+  stdout.write('\n');
+  // TODO highlight LLM output with something like Prism.JS (maybe system emoj are enough ✅⚠️❌)
+  display(outputContent);
+  try {
+    writeFileSync(filePath, outputContent);
+    displaySuccess(`This report can be found in ${filePath}`);
+  } catch (error) {
+    displayDebug(error instanceof Error ? error : String(error));
+    displayError(`Failed to write review to file: ${filePath}`);
+    // Consider if you want to exit or just log the error
+    // 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);
+}