gaunt-sloth-assistant 0.5.0 → 0.5.1

package/src/commands/reviewCommand.ts

@@ -1,36 +1,20 @@
 import { Command, Option } from 'commander';
-import type { SlothContext } from '#src/config.js';
-import { slothContext } from '#src/config.js';
-import { readBackstory, readGuidelines, readReviewInstructions } from '#src/prompt.js';
+import {
+  readBackstory,
+  readGuidelines,
+  readReviewInstructions,
+  readSystemPrompt,
+} from '#src/prompt.js';
 import { readMultipleFilesFromCurrentDir } from '#src/utils.js';
-import { displayError } from '#src/consoleUtils.js';
 import { getStringFromStdin } from '#src/systemUtils.js';
-
-/**
- * Requirements providers. Expected to be in `.providers/` dir.
- * Aliases are mapped to actual providers in this file
- */
-const REQUIREMENTS_PROVIDERS = {
-  'jira-legacy': 'jiraIssueLegacyProvider.js',
-  jira: 'jiraIssueProvider.js',
-  github: 'ghIssueProvider.js',
-  text: 'text.js',
-  file: 'file.js',
-} as const;
-
-type RequirementsProviderType = keyof typeof REQUIREMENTS_PROVIDERS;
-
-/**
- * Content providers. Expected to be in `.providers/` dir.
- * Aliases are mapped to actual providers in this file
- */
-const CONTENT_PROVIDERS = {
-  github: 'ghPrDiffProvider.js',
-  text: 'text.js',
-  file: 'file.js',
-} as const;
-
-type ContentProviderType = keyof typeof CONTENT_PROVIDERS;
+import {
+  REQUIREMENTS_PROVIDERS,
+  CONTENT_PROVIDERS,
+  type RequirementsProviderType,
+  type ContentProviderType,
+  getRequirementsFromProvider,
+  getContentFromProvider,
+} from './commandUtils.js';
 
 interface ReviewCommandOptions {
   file?: string[];
@@ -40,12 +24,7 @@ interface ReviewCommandOptions {
   message?: string;
 }
 
-interface PrCommandOptions {
-  file?: string[];
-  requirementsProvider?: RequirementsProviderType;
-}
-
-export function reviewCommand(program: Command, context: SlothContext): void {
+export function reviewCommand(program: Command): void {
   program
     .command('review')
     .description('Review provided diff or other content')
@@ -75,32 +54,38 @@ export function reviewCommand(program: Command, context: SlothContext): void {
     .option('-m, --message <message>', 'Extra message to provide just before the content')
     .action(async (contentId: string | undefined, options: ReviewCommandOptions) => {
       const { initConfig } = await import('#src/config.js');
-      await initConfig();
+      const config = await initConfig(); // Initialize and get config
+      const systemPrompt = readSystemPrompt();
       const systemMessage = [
         readBackstory(),
-        readGuidelines(slothContext.config.projectGuidelines),
-        readReviewInstructions(slothContext.config.projectReviewInstructions),
+        readGuidelines(config.projectGuidelines),
+        readReviewInstructions(config.projectReviewInstructions),
       ];
+      if (systemPrompt) {
+        systemMessage.push(systemPrompt);
+      }
       const content: string[] = [];
       const requirementsId = options.requirements;
       const requirementsProvider =
         options.requirementsProvider ??
-        (context.config?.commands?.review?.requirementsProvider as
-          | RequirementsProviderType
-          | undefined) ??
-        (context.config?.requirementsProvider as RequirementsProviderType | undefined);
+        (config?.commands?.review?.requirementsProvider as RequirementsProviderType | undefined) ??
+        (config?.requirementsProvider as RequirementsProviderType | undefined);
       const contentProvider =
         options.contentProvider ??
-        (context.config?.commands?.review?.contentProvider as ContentProviderType | undefined) ??
-        (context.config?.contentProvider as ContentProviderType | undefined);
+        (config?.commands?.review?.contentProvider as ContentProviderType | undefined) ??
+        (config?.contentProvider as ContentProviderType | undefined);
 
       // TODO consider calling these in parallel
-      const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
+      const requirements = await getRequirementsFromProvider(
+        requirementsProvider,
+        requirementsId,
+        config
+      );
       if (requirements) {
         content.push(requirements);
       }
 
-      const providedContent = await getContentFromProvider(contentProvider, contentId);
+      const providedContent = await getContentFromProvider(contentProvider, contentId, config);
       if (providedContent) {
         content.push(providedContent);
       }
@@ -116,113 +101,6 @@ export function reviewCommand(program: Command, context: SlothContext): void {
         content.push(options.message);
       }
       const { review } = await import('#src/modules/reviewModule.js');
-      await review('REVIEW', systemMessage.join('\n'), content.join('\n'));
-    });
-
-  program
-    .command('pr')
-    .description(
-      'Review provided Pull Request in current directory. ' +
-        'This command is similar to `review`, but default content provider is `github`. ' +
-        '(assuming that GitHub CLI is installed and authenticated for current project'
-    )
-    .argument('<prId>', 'Pull request ID to review.')
-    .argument(
-      '[requirementsId]',
-      'Optional requirements ID argument to retrieve requirements with requirements provider'
-    )
-    .addOption(
-      new Option(
-        '-p, --requirements-provider <requirementsProvider>',
-        'Requirements provider for this review.'
-      ).choices(Object.keys(REQUIREMENTS_PROVIDERS))
-    )
-    .option(
-      '-f, --file [files...]',
-      'Input files. Content of these files will be added BEFORE the diff, but after requirements'
-    )
-    .action(async (prId: string, requirementsId: string | undefined, options: PrCommandOptions) => {
-      const { initConfig } = await import('#src/config.js');
-      await initConfig();
-
-      const systemMessage = [
-        readBackstory(),
-        readGuidelines(slothContext.config.projectGuidelines),
-        readReviewInstructions(slothContext.config.projectReviewInstructions),
-      ];
-      const content: string[] = [];
-      const requirementsProvider =
-        options.requirementsProvider ??
-        (context.config?.commands?.pr?.requirementsProvider as
-          | RequirementsProviderType
-          | undefined) ??
-        (context.config?.requirementsProvider as RequirementsProviderType | undefined);
-
-      // Handle requirements
-      const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
-      if (requirements) {
-        content.push(requirements);
-      }
-
-      if (options.file) {
-        content.push(readMultipleFilesFromCurrentDir(options.file));
-      }
-
-      // Get PR diff using the 'github' provider
-      const providerPath = `#src/providers/${CONTENT_PROVIDERS['github']}`;
-      const { get } = await import(providerPath);
-      content.push(await get(null, prId));
-
-      const { review } = await import('#src/modules/reviewModule.js');
-      // TODO consider including requirements id
-      // TODO sanitize prId
-      await review(`PR-${prId}`, systemMessage.join('\n'), content.join('\n'));
+      await review('REVIEW', systemMessage.join('\n'), content.join('\n'), config);
     });
-
-  async function getRequirementsFromProvider(
-    requirementsProvider: RequirementsProviderType | undefined,
-    requirementsId: string | undefined
-  ): Promise<string> {
-    return getFromProvider(
-      requirementsProvider,
-      requirementsId,
-      (context.config?.requirementsProviderConfig ?? {})[requirementsProvider as string],
-      REQUIREMENTS_PROVIDERS
-    );
-  }
-
-  async function getContentFromProvider(
-    contentProvider: ContentProviderType | undefined,
-    contentId: string | undefined
-  ): Promise<string> {
-    return getFromProvider(
-      contentProvider,
-      contentId,
-      (context.config?.contentProviderConfig ?? {})[contentProvider as string],
-      CONTENT_PROVIDERS
-    );
-  }
-
-  async function getFromProvider(
-    provider: RequirementsProviderType | ContentProviderType | undefined,
-    id: string | undefined,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    config: any,
-    legitPredefinedProviders: typeof REQUIREMENTS_PROVIDERS | typeof CONTENT_PROVIDERS
-  ): Promise<string> {
-    if (typeof provider === 'string') {
-      // Use one of the predefined providers
-      if (legitPredefinedProviders[provider as keyof typeof legitPredefinedProviders]) {
-        const providerPath = `#src/providers/${legitPredefinedProviders[provider as keyof typeof legitPredefinedProviders]}`;
-        const { get } = await import(providerPath);
-        return await get(config, id);
-      } else {
-        displayError(`Unknown provider: ${provider}. Continuing without it.`);
-      }
-    } else if (typeof provider === 'function') {
-      // Type assertion to handle function call
-      return await (provider as (id: string | undefined) => Promise<string>)(id);
-    }
-    return '';
-  }
 }

package/src/config.ts

@@ -5,6 +5,13 @@ import { error, exit } from '#src/systemUtils.js';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 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
@@ -13,16 +20,7 @@ export interface SlothConfig extends BaseSlothConfig {
   projectGuidelines: string;
   projectReviewInstructions: string;
   streamOutput: boolean;
-  commands: {
-    pr: {
-      contentProvider: string;
-      requirementsProvider?: string;
-    };
-    review?: {
-      requirementsProvider?: string;
-      contentProvider?: string;
-    };
-  };
+  filesystem: string[] | 'all' | 'none';
 }
 
 /**
@@ -42,14 +40,20 @@ interface BaseSlothConfig {
   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>;
@@ -57,26 +61,11 @@ interface BaseSlothConfig {
   mcpServers?: Record<string, Connection>;
 }
 
-/**
- * @deprecated
- * this object has blurred responsibility lines and bad name.
- */
-export interface SlothContext {
-  config: SlothConfig;
-}
-
 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 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];
 
@@ -87,6 +76,15 @@ export const DEFAULT_CONFIG: Partial<SlothConfig> = {
   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
@@ -96,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,
-} 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));
@@ -133,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 {
@@ -287,12 +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;
+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