gaunt-sloth-assistant 0.5.0 → 0.5.1

package/src/llmUtils.ts

@@ -1,11 +1,14 @@
 import type { Message } from '#src/modules/types.js';
-import { HumanMessage, isAIMessageChunk, SystemMessage } from '@langchain/core/messages';
+import { HumanMessage, isAIMessage, SystemMessage } from '@langchain/core/messages';
 import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { SlothConfig } from '#src/config.js';
+import type { Connection } from '@langchain/mcp-adapters';
 import { MultiServerMCPClient } from '@langchain/mcp-adapters';
-import { display, displayError, displayInfo } from '#src/consoleUtils.js';
+import { display, displayError, displayInfo, displayWarning } from '#src/consoleUtils.js';
 import { createReactAgent } from '@langchain/langgraph/prebuilt';
-import { stdout } from '#src/systemUtils.js';
+import { getCurrentDir, stdout } from '#src/systemUtils.js';
+import type { StructuredToolInterface } from '@langchain/core/tools';
+import { ProgressIndicator } from '#src/utils.js';
 
 const llmGlobalSettings = {
   verbose: false,
@@ -15,17 +18,35 @@ export async function invoke(
   llm: BaseChatModel,
   systemMessage: string,
   prompt: string,
-  config: SlothConfig
+  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;
   }
 
-  const client = getClient(config);
+  // 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');
 
-  const tools = (await client?.getTools()) ?? [];
-  if (tools && tools.length > 0) {
-    displayInfo(`Loaded ${tools.length} MCP tools.`);
+  if (allTools.length > 0) {
+    displayInfo(`Loaded ${tools.length} tools.`);
   }
 
   // Create the React agent
@@ -38,20 +59,37 @@ export async function invoke(
   try {
     const messages: Message[] = [new SystemMessage(systemMessage), new HumanMessage(prompt)];
     display(`Connecting to LLM...`);
-    const stream = await agent.stream({ messages }, { streamMode: 'messages' });
-
     const output = { aiMessage: '' };
-    for await (const [chunk, _metadata] of stream) {
-      if (isAIMessageChunk(chunk)) {
-        if (config.streamOutput) {
-          stdout.write(chunk.content as string, 'utf-8');
+    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(', ')}`);
         }
-        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}`);
+      } 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}`);
+          }
         }
       }
     }
@@ -66,7 +104,6 @@ export async function invoke(
     throw error;
   } finally {
     if (client) {
-      console.log('closing');
       await client.close();
     }
   }
@@ -76,13 +113,53 @@ 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) {
-  if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+  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: config.mcpServers,
+      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,15 @@ import { invoke } from '#src/llmUtils.js';
 export async function askQuestion(
   source: string,
   preamble: string,
-  content: string
+  content: string,
+  config: SlothConfig
 ): Promise<void> {
-  const progressIndicator = slothContext.config.streamOutput
-    ? undefined
-    : new ProgressIndicator('Thinking.');
-  const outputContent = await invoke(
-    slothContext.config.llm,
-    preamble,
-    content,
-    slothContext.config
-  );
+  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);
-  if (!slothContext.config.streamOutput) {
+  if (!config.streamOutput) {
     display('\n' + outputContent);
   }
   try {

package/src/modules/reviewModule.ts

@@ -1,19 +1,23 @@
-import { slothContext } from '#src/config.js';
+import type { SlothConfig } from '#src/config.js';
 import { display, displayDebug, displayError, displaySuccess } from '#src/consoleUtils.js';
 import { generateStandardFileName, ProgressIndicator } from '#src/utils.js';
 import { writeFileSync } from 'node:fs';
 import { invoke } from '#src/llmUtils.js';
 import { getGslothFilePath } from '#src/filePathUtils.js';
 
-export async function review(source: string, preamble: string, diff: string): Promise<void> {
-  const progressIndicator = slothContext.config.streamOutput
-    ? undefined
-    : new ProgressIndicator('Reviewing.');
-  const outputContent = await invoke(slothContext.config.llm, preamble, diff, slothContext.config);
+export async function review(
+  source: string,
+  preamble: string,
+  diff: string,
+  config: SlothConfig,
+  command: 'pr' | 'review' = 'review'
+): Promise<void> {
+  const progressIndicator = config.streamOutput ? undefined : new ProgressIndicator('Reviewing.');
+  const outputContent = await invoke(config.llm, preamble, diff, config, command);
   progressIndicator?.stop();
   const filename = generateStandardFileName(source);
   const filePath = getGslothFilePath(filename);
-  if (!slothContext.config.streamOutput) {
+  if (!config.streamOutput) {
     display('\n' + outputContent);
   }
   try {

package/src/prompt.ts

@@ -5,7 +5,7 @@ import {
 } from '#src/utils.js';
 import { displayError } from '#src/consoleUtils.js';
 import { exit } from '#src/systemUtils.js';
-import { GSLOTH_BACKSTORY } from '#src/config.js';
+import { GSLOTH_BACKSTORY, GSLOTH_SYSTEM_PROMPT } from '#src/constants.js';
 import { getGslothConfigReadPath } from '#src/filePathUtils.js';
 
 export function readBackstory(): string {
@@ -28,6 +28,10 @@ export function readReviewInstructions(reviewInstructions: string): string {
   return readConfigPromptFile(reviewInstructions);
 }
 
+export function readSystemPrompt(): string {
+  return readFileFromCurrentOrInstallDir(GSLOTH_SYSTEM_PROMPT, true);
+}
+
 function readConfigPromptFile(guidelinesFilename: string): string {
   try {
     const filePath = getGslothConfigReadPath(guidelinesFilename);

package/src/providers/ghIssueProvider.ts

@@ -1,5 +1,5 @@
 import { displayWarning } from '#src/consoleUtils.js';
-import { execAsync } from '#src/utils.js';
+import { execAsync, ProgressIndicator } from '#src/utils.js';
 import type { ProviderConfig } from './types.js';
 
 /**
@@ -19,7 +19,9 @@ export async function get(
 
   try {
     // Use the GitHub CLI to fetch issue details
+    const progress = new ProgressIndicator(`Fetching GitHub issue #${issueId}`);
     const issueContent = await execAsync(`gh issue view ${issueId}`);
+    progress.stop();
 
     if (!issueContent) {
       displayWarning(`No content found for GitHub issue #${issueId}`);

package/src/providers/ghPrDiffProvider.ts

@@ -1,5 +1,5 @@
 import { displayWarning } from '#src/consoleUtils.js';
-import { execAsync } from '#src/utils.js';
+import { execAsync, ProgressIndicator } from '#src/utils.js';
 import type { ProviderConfig } from './types.js';
 
 /**
@@ -19,7 +19,9 @@ export async function get(
 
   try {
     // Use the GitHub CLI to fetch PR diff
+    const progress = new ProgressIndicator(`Fetching GitHub PR #${prId} diff`);
     const prDiffContent = await execAsync(`gh pr diff ${prId}`);
+    progress.stop();
 
     if (!prDiffContent) {
       displayWarning(`No diff content found for GitHub PR #${prId}`);