gaunt-sloth-assistant 0.4.2 → 0.5.1

package/src/config.ts

@@ -1,10 +1,17 @@
-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 } from '#src/systemUtils.js';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { getGslothConfigWritePath, getGslothConfigReadPath } from '#src/filePathUtils.js';
+import { getGslothConfigReadPath, getGslothConfigWritePath } from '#src/filePathUtils.js';
+import type { Connection } from '@langchain/mcp-adapters';
+import {
+  USER_PROJECT_CONFIG_JS,
+  USER_PROJECT_CONFIG_JSON,
+  USER_PROJECT_CONFIG_MJS,
+  PROJECT_GUIDELINES,
+  PROJECT_REVIEW_INSTRUCTIONS,
+} from '#src/constants.js';
 
 export interface SlothConfig extends BaseSlothConfig {
   llm: BaseChatModel; // FIXME this is still bad keeping instance in config is probably not best choice
@@ -12,16 +19,8 @@ export interface SlothConfig extends BaseSlothConfig {
   requirementsProvider: string;
   projectGuidelines: string;
   projectReviewInstructions: string;
-  commands: {
-    pr: {
-      contentProvider: string;
-      requirementsProvider?: string;
-    };
-    review?: {
-      requirementsProvider?: string;
-      contentProvider?: string;
-    };
-  };
+  streamOutput: boolean;
+  filesystem: string[] | 'all' | 'none';
 }
 
 /**
@@ -40,31 +39,26 @@ interface BaseSlothConfig {
   requirementsProvider?: string;
   projectGuidelines?: string;
   projectReviewInstructions?: string;
+  streamOutput?: boolean;
+  filesystem?: string[] | 'all' | 'none';
   commands?: {
-    pr: {
-      contentProvider: string;
+    pr?: {
+      contentProvider?: string;
       requirementsProvider?: string;
+      filesystem?: string[] | 'all' | 'none';
     };
     review?: {
       requirementsProvider?: string;
       contentProvider?: string;
+      filesystem?: string[] | 'all' | 'none';
+    };
+    ask?: {
+      filesystem?: string[] | 'all' | 'none';
     };
   };
   requirementsProviderConfig?: Record<string, unknown>;
   contentProviderConfig?: Record<string, unknown>;
-}
-
-/**
- * @deprecated
- * this object has blurred responsibility lines and bad name.
- */
-export interface SlothContext {
-  config: SlothConfig;
-  session: {
-    configurable: {
-      thread_id: string;
-    };
-  };
+  mcpServers?: Record<string, Connection>;
 }
 
 export interface LLMConfig extends Record<string, unknown> {
@@ -72,13 +66,6 @@ export interface LLMConfig extends Record<string, unknown> {
   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 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];
 
@@ -88,6 +75,16 @@ export const DEFAULT_CONFIG: Partial<SlothConfig> = {
   requirementsProvider: 'file',
   projectGuidelines: PROJECT_GUIDELINES,
   projectReviewInstructions: PROJECT_REVIEW_INSTRUCTIONS,
+  streamOutput: true,
+  filesystem: [
+    'read_file',
+    'read_multiple_files',
+    'list_directory',
+    'directory_tree',
+    'search_files',
+    'get_file_info',
+    'list_allowed_directories',
+  ],
   commands: {
     pr: {
       contentProvider: 'github', // gh pr diff NN
@@ -97,30 +94,26 @@ export const DEFAULT_CONFIG: Partial<SlothConfig> = {
 };
 
 /**
- * @deprecated
- * this object has blurred responsibility lines and bad name.
- * TODO this should be reworked to something more robust
+ * Initialize configuration by loading from available config files
+ * @returns The loaded SlothConfig
  */
-export const slothContext = {
-  config: DEFAULT_CONFIG,
-  session: { configurable: { thread_id: uuidv4() } },
-} as Partial<SlothContext> as SlothContext;
-
-export async function initConfig(): Promise<void> {
+export async function initConfig(): Promise<SlothConfig> {
   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
+  // Try loading the JSON config file first
   if (existsSync(jsonConfigPath)) {
     try {
+      // TODO makes sense to employ ZOD to validate config
       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);
+        return await tryJsonConfig(jsonConfig);
       } else {
         error(`${jsonConfigPath} is not in valid format. Should at least define llm.type`);
         exit(1);
+        // noinspection ExceptionCaughtLocallyJS
+        // This throw is unreachable due to exit(1) above, but satisfies TS type analysis and prevents tests from exiting
+        throw new Error('Unexpected error occurred.');
       }
     } catch (e) {
       displayDebug(e instanceof Error ? e : String(e));
@@ -134,113 +127,113 @@ export async function initConfig(): Promise<void> {
     // 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
+// Helper function to try loading JS config
+async function tryJsConfig(): Promise<SlothConfig> {
+  const jsConfigPath = getGslothConfigReadPath(USER_PROJECT_CONFIG_JS);
+  if (existsSync(jsConfigPath)) {
+    try {
+      const i = await importExternalFile(jsConfigPath);
+      const customConfig = await i.configure(jsConfigPath);
+      return mergeConfig(customConfig) as SlothConfig;
+    } 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();
     }
-  }
-
-  // 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();
-    }
+  } else {
+    // JS config not found, try MJS
+    return tryMjsConfig();
   }
 }
 
-// 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)) {
+// Helper function to try loading MJS config
+async function tryMjsConfig(): Promise<SlothConfig> {
+  const mjsConfigPath = getGslothConfigReadPath(USER_PROJECT_CONFIG_MJS);
+  if (existsSync(mjsConfigPath)) {
+    try {
+      const i = await importExternalFile(mjsConfigPath);
+      const customConfig = await i.configure(mjsConfigPath);
+      return mergeConfig(customConfig) as SlothConfig;
+    } 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(1);
+    }
+  } else {
+    // No config files found
     displayError(
-      `Unsupported LLM type: ${llmType}. Available types are: ${availableDefaultConfigs.join(', ')}`
+      '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(1);
-    return;
   }
+  // This throw is unreachable due to exit(1) above, but satisfies TS type analysis and prevents tests from exiting
+  throw new Error('Unexpected error occurred.');
+}
 
+/**
+ * Process JSON LLM config by creating the appropriate LLM instance
+ * @param jsonConfig - The parsed JSON config
+ * @returns Promise<SlothConfig>
+ */
+export async function tryJsonConfig(jsonConfig: RawSlothConfig): Promise<SlothConfig> {
   try {
-    // Import the appropriate config module based on the LLM type
-    try {
+    if (jsonConfig.llm && typeof jsonConfig.llm === 'object') {
+      // Get the type of LLM (e.g., 'vertexai', 'anthropic') - this should exist
+      const llmType = (jsonConfig.llm as LLMConfig).type;
+      if (!llmType) {
+        displayError('LLM type not specified in config.');
+        exit(1);
+      }
+
+      // Get the configuration for the specific LLM type
+      const llmConfig = jsonConfig.llm;
+      // Import the appropriate config module
       const configModule = await import(`./configs/${llmType}.js`);
       if (configModule.processJsonConfig) {
         const llm = (await configModule.processJsonConfig(llmConfig)) as BaseChatModel;
-        slothContext.config = { ...slothContext.config, ...jsonConfig, llm };
+        return mergeRawConfig(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}.`);
+    } else {
+      displayError('No LLM configuration found in config.');
       exit(1);
     }
-  } catch (error) {
-    displayDebug(error instanceof Error ? error : String(error));
-    displayError(`Error creating LLM instance for type ${llmType}.`);
+  } catch (e) {
+    if (e instanceof Error && e.message.includes('Cannot find module')) {
+      displayError(`LLM type '${(jsonConfig.llm as LLMConfig).type}' not supported.`);
+    } else {
+      displayError(`Error processing LLM config: ${e instanceof Error ? e.message : String(e)}`);
+    }
     exit(1);
   }
+  // This throw is unreachable due to exit(1) above, but satisfies TS type analysis and prevents tests from exiting
+  throw new Error('Unexpected error occurred.');
 }
 
 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 ${PROJECT_GUIDELINES}.\n`);
-
-  // Check if the config type is in availableDefaultConfigs
+  // Check if the config type is valid
   if (!availableDefaultConfigs.includes(configType as ConfigType)) {
     displayError(
-      `Unsupported config type: ${configType}. Available types are: ${availableDefaultConfigs.join(', ')}`
+      `Unknown config type: ${configType}. Available options: ${availableDefaultConfigs.join(', ')}`
     );
     exit(1);
-    return;
   }
 
+  displayInfo(`Setting up your project\n`);
+  writeProjectReviewPreamble();
+  displayWarning(`Make sure you add as much detail as possible to your ${PROJECT_GUIDELINES}.\n`);
+
   displayInfo(`Creating project config for ${configType}`);
   const vendorConfig = await import(`./configs/${configType}.js`);
-  vendorConfig.init(getGslothConfigWritePath(USER_PROJECT_CONFIG_JSON), slothContext);
+  vendorConfig.init(getGslothConfigWritePath(USER_PROJECT_CONFIG_JSON));
 }
 
 export function writeProjectReviewPreamble(): void {
@@ -288,13 +281,20 @@ Important! You are likely to be dealing with git diff below, please don't confus
 }
 
 /**
- * @deprecated test only
- * TODO should be gone together with slothContext itself
+ * Merge config with default config
+ */
+function mergeConfig(partialConfig: Partial<SlothConfig>): SlothConfig {
+  const config = partialConfig as SlothConfig;
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    commands: { ...DEFAULT_CONFIG.commands, ...(config?.commands ?? {}) },
+  };
+}
+
+/**
+ * Merge raw with default config
  */
-export function reset() {
-  Object.keys(slothContext).forEach((key) => {
-    delete (slothContext as unknown as Record<string, unknown>)[key];
-  });
-  slothContext.config = DEFAULT_CONFIG as SlothConfig;
-  slothContext.session = { configurable: { thread_id: uuidv4() } };
+function mergeRawConfig(config: RawSlothConfig, llm: BaseChatModel): SlothConfig {
+  return mergeConfig({ ...config, llm });
 }

package/src/constants.ts

@@ -0,0 +1,7 @@
+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 PROJECT_GUIDELINES = '.gsloth.guidelines.md';
+export const PROJECT_REVIEW_INSTRUCTIONS = '.gsloth.review.md';
+export const GSLOTH_SYSTEM_PROMPT = '.gsloth.system.md';

package/src/index.ts

@@ -2,7 +2,7 @@ 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 { prCommand } from '#src/commands/prCommand.js';
 import { getSlothVersion } from '#src/utils.js';
 import { argv, readStdin } from '#src/systemUtils.js';
 import { setVerbose } from '#src/llmUtils.js';
@@ -22,8 +22,10 @@ if (program.getOptionValue('verbose')) {
   setVerbose(true);
 }
 
+// Initialize all commands - they will handle their own config loading
 initCommand(program);
-reviewCommand(program, slothContext);
+reviewCommand(program);
+prCommand(program);
 askCommand(program);
 // TODO add general interactive chat command
 

package/src/llmUtils.ts

@@ -1,8 +1,14 @@
-import type { Message, State } from '#src/modules/types.js';
-import { AIMessageChunk, HumanMessage, SystemMessage } from '@langchain/core/messages';
+import type { Message } from '#src/modules/types.js';
+import { HumanMessage, isAIMessage, 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';
+import { SlothConfig } from '#src/config.js';
+import type { Connection } from '@langchain/mcp-adapters';
+import { MultiServerMCPClient } from '@langchain/mcp-adapters';
+import { display, displayError, displayInfo, displayWarning } from '#src/consoleUtils.js';
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { getCurrentDir, stdout } from '#src/systemUtils.js';
+import type { StructuredToolInterface } from '@langchain/core/tools';
+import { ProgressIndicator } from '#src/utils.js';
 
 const llmGlobalSettings = {
   verbose: false,
@@ -10,45 +16,152 @@ const llmGlobalSettings = {
 
 export async function invoke(
   llm: BaseChatModel,
-  options: Partial<BaseLanguageModelCallOptions>,
   systemMessage: string,
-  prompt: string
+  prompt: string,
+  config: SlothConfig,
+  command?: 'ask' | 'pr' | 'review'
 ): Promise<string> {
+  try {
+    if (config.streamOutput && config.llm._llmType() === 'anthropic') {
+      displayWarning('To avoid known bug with Anthropic forcing streamOutput to false');
+      config.streamOutput = false;
+    }
+  } catch {}
   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);
+
+  // Merge command-specific filesystem config if provided
+  let effectiveConfig = config;
+  if (command && config.commands?.[command]?.filesystem !== undefined) {
+    effectiveConfig = {
+      ...config,
+      filesystem: config.commands[command].filesystem!,
+    };
+  }
+
+  const client = getClient(effectiveConfig);
+
+  const allTools = (await client?.getTools()) ?? [];
+  const tools = filterTools(allTools, effectiveConfig.filesystem || 'none');
+
+  if (allTools.length > 0) {
+    displayInfo(`Loaded ${tools.length} tools.`);
+  }
+
+  // Create the React agent
+  const agent = createReactAgent({
+    llm,
+    tools,
+  });
+
+  // Run the agent
+  try {
+    const messages: Message[] = [new SystemMessage(systemMessage), new HumanMessage(prompt)];
+    display(`Connecting to LLM...`);
+    const output = { aiMessage: '' };
+    if (!config.streamOutput) {
+      const progress = new ProgressIndicator('Thinking.');
+      try {
+        const response = await agent.invoke({ messages });
+        output.aiMessage = response.messages[response.messages.length - 1].content as string;
+        const toolNames = response.messages
+          .filter((msg: any) => msg.tool_calls && msg.tool_calls.length > 0)
+          .flatMap((msg: any) => msg.tool_calls.map((tc: any) => tc.name));
+        if (toolNames.length > 0) {
+          displayInfo(`\nUsed tools: ${toolNames.join(', ')}`);
+        }
+      } catch (e) {
+        displayWarning(`Something went wrong ${(e as Error).message}`);
+      } finally {
+        progress.stop();
+      }
+      display(output.aiMessage);
+    } else {
+      const stream = await agent.stream({ messages }, { streamMode: 'messages' });
+
+      for await (const [chunk, _metadata] of stream) {
+        if (isAIMessage(chunk)) {
+          stdout.write(chunk.content as string, 'utf-8');
+          output.aiMessage += chunk.content;
+          let toolCalls = chunk.tool_calls;
+          if (toolCalls && toolCalls.length > 0) {
+            const suffix = toolCalls.length > 1 ? 's' : '';
+            const toolCallsString = toolCalls.map((t) => t?.name).join(', ');
+            displayInfo(`Using tool${suffix} ${toolCallsString}`);
+          }
+        }
+      }
+    }
+
+    return output.aiMessage;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error?.name === 'ToolException') {
+        displayError(`Tool execution failed: ${error.message}`);
+      }
+    }
+    throw error;
+  } finally {
+    if (client) {
+      await client.close();
+    }
+  }
 }
 
 export function setVerbose(debug: boolean) {
   llmGlobalSettings.verbose = debug;
 }
+
+function filterTools(
+  tools: StructuredToolInterface[],
+  filesystemConfig: string[] | 'all' | 'none'
+) {
+  if (filesystemConfig === 'all' || !Array.isArray(filesystemConfig)) {
+    return tools;
+  }
+
+  // Create set of allowed tool names with mcp__filesystem__ prefix
+  const allowedToolNames = new Set(
+    filesystemConfig.map((shortName) => `mcp__filesystem__${shortName}`)
+  );
+
+  return tools.filter((tool) => {
+    // Allow non-filesystem tools and only allowed filesystem tools
+    return !tool.name.startsWith('mcp__filesystem__') || allowedToolNames.has(tool.name);
+  });
+}
+
+function getClient(config: SlothConfig) {
+  const defaultServers: Record<string, Connection> = {};
+
+  // Add filesystem server if configured
+  if (config.filesystem && config.filesystem !== 'none') {
+    const filesystemConfig: Connection = {
+      transport: 'stdio' as const,
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-filesystem', getCurrentDir()],
+    };
+
+    defaultServers.filesystem = filesystemConfig;
+  }
+
+  // Merge with user's mcpServers
+  const mcpServers = { ...defaultServers, ...(config.mcpServers || {}) };
+
+  // If user provided their own filesystem config, it overrides default
+  if (config.mcpServers?.filesystem) {
+    mcpServers.filesystem = config.mcpServers.filesystem;
+  }
+
+  if (Object.keys(mcpServers).length > 0) {
+    return new MultiServerMCPClient({
+      throwOnLoadError: true,
+      prefixToolNameWithServerName: true,
+      additionalToolNamePrefix: 'mcp',
+      mcpServers,
+    });
+  } else {
+    return null;
+  }
+}

package/src/modules/questionAnsweringModule.ts

@@ -1,4 +1,4 @@
-import { slothContext } from '#src/config.js';
+import type { SlothConfig } from '#src/config.js';
 import { display, displayError, displaySuccess } from '#src/consoleUtils.js';
 import { getGslothFilePath } from '#src/filePathUtils.js';
 import { generateStandardFileName, ProgressIndicator } from '#src/utils.js';
@@ -14,21 +14,17 @@ import { invoke } from '#src/llmUtils.js';
 export async function askQuestion(
   source: string,
   preamble: string,
-  content: string
+  content: string,
+  config: SlothConfig
 ): Promise<void> {
-  const progressIndicator = new ProgressIndicator('Thinking.');
-  const outputContent = await invoke(
-    slothContext.config.llm,
-    slothContext.session,
-    preamble,
-    content
-  );
-  progressIndicator.stop();
+  const progressIndicator = config.streamOutput ? undefined : new ProgressIndicator('Thinking.');
+  const outputContent = await invoke(config.llm, preamble, content, config, 'ask');
+  progressIndicator?.stop();
   const filename = generateStandardFileName(source);
   const filePath = getGslothFilePath(filename);
-  display(`\nwriting ${filePath}`);
-  // TODO highlight LLM output with something like Prism.JS (maybe system emoj are enough ✅⚠️❌)
-  display('\n' + outputContent);
+  if (!config.streamOutput) {
+    display('\n' + outputContent);
+  }
   try {
     writeFileSync(filePath, outputContent);
     displaySuccess(`This report can be found in ${filePath}`);