gaunt-sloth-assistant 0.1.2 → 0.1.4

package/spec/reviewCommand.spec.js

@@ -4,14 +4,37 @@ import * as td from 'testdouble';
 describe('reviewCommand',  function (){
 
     beforeEach(async function() {
+        td.reset();
         this.review = td.function();
         this.prompt = await td.replaceEsm("../src/prompt.js");
         td.when(this.prompt.readInternalPreamble()).thenReturn("INTERNAL PREAMBLE");
         td.when(this.prompt.readPreamble(".gsloth.preamble.review.md")).thenReturn("PROJECT PREAMBLE");
         this.codeReviewMock = await td.replaceEsm("../src/modules/reviewModule.js");
-        await td.replaceEsm("../src/config.js");
-        this.utils = await td.replaceEsm("../src/utils.js");
-        td.when(this.utils.readFileFromCurrentDir("test.file")).thenReturn("FILE TO REVIEW");
+        await td.replaceEsm("../src/config.js", {
+            SLOTH_INTERNAL_PREAMBLE: '.gsloth.preamble.internal.md',
+            USER_PROJECT_REVIEW_PREAMBLE: '.gsloth.preamble.review.md',
+            slothContext: {
+                config: {},
+                currentDir: '/mock/current/dir'
+            },
+            initConfig: td.function()
+        });
+        const readFileFromCurrentDir = td.function();
+        const readMultipleFilesFromCurrentDir = td.function();
+        const extractLastMessageContent = td.function();
+        const toFileSafeString = td.function();
+        const fileSafeLocalDate = td.function();
+        this.utilsMock = {
+            readFileFromCurrentDir,
+            readMultipleFilesFromCurrentDir,
+            ProgressIndicator: td.constructor(),
+            extractLastMessageContent,
+            toFileSafeString,
+            fileSafeLocalDate
+        };
+        await td.replaceEsm("../src/utils.js", this.utilsMock);
+        td.when(this.utilsMock.readFileFromCurrentDir("test.file")).thenReturn("FILE TO REVIEW");
+        td.when(this.utilsMock.readMultipleFilesFromCurrentDir(["test.file"])).thenReturn("test.file:\n```\nFILE TO REVIEW\n```");
         td.when(this.codeReviewMock.review(
             'sloth-DIFF-review',
             td.matchers.anything(),
@@ -21,7 +44,7 @@ describe('reviewCommand',  function (){
 
     it('Should call review with file contents', async function() {
         const { reviewCommand } = await import("../src/commands/reviewCommand.js");
-        const program = new Command()
+        const program = new Command();
         await reviewCommand(program, {});
         await program.parseAsync(['na', 'na', 'review', '-f', 'test.file']);
         td.verify(this.review(
@@ -31,6 +54,20 @@ describe('reviewCommand',  function (){
         );
     });
 
+    it('Should call review with multiple file contents', async function() {
+        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
+        const program = new Command();
+        await reviewCommand(program, {});
+        td.when(this.utilsMock.readMultipleFilesFromCurrentDir(["test.file", "test2.file"]))
+            .thenReturn("test.file:\n```\nFILE TO REVIEW\n```\n\ntest2.file:\n```\nFILE2 TO REVIEW\n```");
+        await program.parseAsync(['na', 'na', 'review', '-f', 'test.file', 'test2.file']);
+        td.verify(this.review(
+            'sloth-DIFF-review',
+            "INTERNAL PREAMBLE\nPROJECT PREAMBLE",
+            "test.file:\n```\nFILE TO REVIEW\n```\n\ntest2.file:\n```\nFILE2 TO REVIEW\n```")
+        );
+    });
+
     it('Should display predefined providers in help', async function() {
         const { reviewCommand } = await import("../src/commands/reviewCommand.js");
         const program = new Command();
@@ -43,17 +80,18 @@ describe('reviewCommand',  function (){
 
         await reviewCommand(program, {});
 
-        const commandUnderTest = program.commands.find(c => c.name() == 'review');
+        const commandUnderTest = program.commands.find(c => c.name() === 'review');
+
         expect(commandUnderTest).toBeDefined();
         commandUnderTest.outputHelp();
 
         // Verify content providers are displayed
         expect(testOutput.text).toContain('--content-provider <contentProvider>');
-        expect(testOutput.text).toContain('(choices: "gh", "text")');
+        expect(testOutput.text).toContain('(choices: "gh", "text", "file")');
 
         // Verify requirements providers are displayed
         expect(testOutput.text).toContain('--requirements-provider <requirementsProvider>');
-        expect(testOutput.text).toContain('(choices: "jira-legacy", "text")');
+        expect(testOutput.text).toContain('(choices: "jira-legacy", "text", "file")');
     });
 
     it('Should call review with predefined requirements provider', async function() {
@@ -87,6 +125,46 @@ describe('reviewCommand',  function (){
         td.verify(this.review('sloth-DIFF-review', "INTERNAL PREAMBLE\nPROJECT PREAMBLE", "JIRA Requirements"));
     });
 
+    it('Should display meaningful error, when JIRA is enabled, but JIRA token is absent', async function() {
+        const testOutput = { text: '' };
+
+        const { reviewCommand } = await import("../src/commands/reviewCommand.js");
+        const program = new Command();
+        program.configureOutput({
+            writeOut: (str) => testOutput.text += str,
+            writeErr: (str) => testOutput.text += str
+        });
+
+        const context = {
+            config: {
+                requirementsProvider: 'jira-legacy',
+                requirementsProviderConfig: {
+                    'jira-legacy': {
+                        username: 'test-user',
+                        baseUrl: 'https://test-jira.atlassian.net/rest/api/2/issue/'
+                    }
+                }
+            }
+        };
+
+        // Mock the jira provider
+        const jiraProvider = td.func();
+        td.when(jiraProvider(td.matchers.anything(), 'JIRA-123')).thenResolve('JIRA Requirements');
+
+
+        await reviewCommand(program, context);
+        try {
+            await program.parseAsync(['na', 'na', 'pr', 'content-id', 'JIRA-123']);
+        } catch (e) {
+            expect(e.message)
+                .toContain(
+                    'Missing JIRA Legacy API token. ' +
+                    'The legacy token can be defined as JIRA_LEGACY_API_TOKEN environment variable ' +
+                    'or as "token" in config.'
+                );
+        }
+    });
+
     it('Should call review with predefined content provider', async function() {
         const { reviewCommand } = await import("../src/commands/reviewCommand.js");
         const program = new Command();
@@ -129,7 +207,7 @@ describe('reviewCommand',  function (){
 
         // Mock the gh provider
         const ghProvider = td.func();
-        td.when(ghProvider('123')).thenResolve('PR Diff Content');
+        td.when(ghProvider(td.matchers.anything(), '123')).thenResolve('PR Diff Content');
 
         // Replace the dynamic import with our mock
         await td.replaceEsm('../src/providers/ghPrDiffProvider.js', {

package/spec/reviewModule.spec.js

@@ -1,9 +1,14 @@
 import { reviewInner } from '../src/modules/reviewModule.js';
 import { slothContext } from '../src/config.js';
 import { FakeListChatModel } from "@langchain/core/utils/testing";
+import * as td from "testdouble";
 
 describe('reviewModule', () => {
 
+  beforeEach(async function() {
+    td.reset();
+  });
+
   it('should invoke LLM', async () => {
     // Setup mock for slothContext
     const testContext = {...slothContext, 
@@ -16,7 +21,8 @@ describe('reviewModule', () => {
 
     // Test the function
     const output = await reviewInner(testContext, () => {}, 'test-preamble', 'test-diff');
+
     expect(output).toBe("First LLM message");
   });
 
-});
+});

package/src/commands/askCommand.js

@@ -1,5 +1,5 @@
 import { readInternalPreamble } from "../prompt.js";
-import { readFileFromCurrentDir } from "../utils.js";
+import { readMultipleFilesFromCurrentDir } from "../utils.js";
 import { initConfig } from "../config.js";
 
 /**
@@ -7,20 +7,21 @@ import { initConfig } from "../config.js";
  * @param {Object} program - The commander program
  * @param {Object} context - The context object
  */
+// eslint-disable-next-line no-unused-vars
 export function askCommand(program, context) {
     program.command('ask')
         .description('Ask a question')
         .argument('<message>', 'A message')
-        .option('-f, --file <file>', 'Input file. Content of this file will be added BEFORE the diff')
+        .option('-f, --file [files...]', 'Input files. Content of these files will be added BEFORE the message')
         // TODO add option consuming extra message as argument
         .action(async (message, options) => {
             const preamble = [readInternalPreamble()];
             const content = [message];
             if (options.file) {
-                content.push(readFileFromCurrentDir(options.file));
+                content.push(readMultipleFilesFromCurrentDir(options.file));
             }
             await initConfig();
             const { askQuestion } = await import('../modules/questionAnsweringModule.js');
             await askQuestion('sloth-ASK', preamble.join("\n"), content.join("\n"));
         });
-}
+}

package/src/commands/initCommand.js

@@ -6,6 +6,7 @@ import { availableDefaultConfigs, createProjectConfig } from "../config.js";
  * @param {Object} program - The commander program
  * @param {Object} context - The context object
  */
+// eslint-disable-next-line no-unused-vars
 export function initCommand(program, context) {
     program.command('init')
         .description('Initialize the Gaunt Sloth Assistant in your project. This will write necessary config files.')
@@ -13,4 +14,4 @@ export function initCommand(program, context) {
         .action(async (config) => {
             await createProjectConfig(config);
         });
-}
+}

package/src/commands/reviewCommand.js

@@ -1,7 +1,7 @@
 import {Option} from 'commander';
 import {USER_PROJECT_REVIEW_PREAMBLE} from "../config.js";
 import {readInternalPreamble, readPreamble} from "../prompt.js";
-import {readFileFromCurrentDir} from "../utils.js";
+import {readMultipleFilesFromCurrentDir} from "../utils.js";
 import {displayError} from "../consoleUtils.js";
 
 /**
@@ -9,7 +9,8 @@ import {displayError} from "../consoleUtils.js";
  */
 const REQUIREMENTS_PROVIDERS = {
     'jira-legacy': 'jiraIssueLegacyAccessTokenProvider.js',
-    'text': 'text.js'
+    'text': 'text.js',
+    'file': 'file.js'
 };
 
 /**
@@ -17,7 +18,8 @@ const REQUIREMENTS_PROVIDERS = {
  */
 const CONTENT_PROVIDERS = {
     'gh': 'ghPrDiffProvider.js',
-    'text': 'text.js'
+    'text': 'text.js',
+    'file': 'file.js'
 };
 
 export function reviewCommand(program, context) {
@@ -27,8 +29,7 @@ export function reviewCommand(program, context) {
         .argument('[contentId]', 'Optional content ID argument to retrieve content with content provider')
         .alias('r')
         // TODO add provider to get results of git --no-pager diff
-        // TODO add support to include multiple files
-        .option('-f, --file <file>', 'Input file. Content of this file will be added BEFORE the diff, but after requirements')
+        .option('-f, --file [files...]', 'Input files. Content of these files will be added BEFORE the diff, but after requirements')
         // TODO figure out what to do with this (we probably want to merge it with requirementsId)?
         .option('-r, --requirements <requirements>', 'Requirements for this review.')
         .addOption(
@@ -46,8 +47,12 @@ export function reviewCommand(program, context) {
             const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
             const content = [];
             const requirementsId = options.requirements;
-            const requirementsProvider = options.requirementsProvider ?? context.config?.requirementsProvider;
-            const contentProvider = options.contentProvider ?? context.config?.contentProvider;
+            const requirementsProvider = options.requirementsProvider
+                ?? context.config?.review?.requirementsProvider
+                ?? context.config?.requirementsProvider;
+            const contentProvider = options.contentProvider
+                ?? context.config?.review?.contentProvider
+                ?? context.config?.contentProvider;
 
             // TODO consider calling these in parallel
             const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
@@ -61,7 +66,7 @@ export function reviewCommand(program, context) {
             }
 
             if (options.file) {
-                content.push(`${options.file}:\n\`\`\`\n${readFileFromCurrentDir(options.file)}\n\`\`\``);
+                content.push(readMultipleFilesFromCurrentDir(options.file));
             }
             if (context.stdin) {
                 content.push(context.stdin);
@@ -83,14 +88,16 @@ export function reviewCommand(program, context) {
             new Option('-p, --requirements-provider <requirementsProvider>', 'Requirements provider for this review.')
                 .choices(Object.keys(REQUIREMENTS_PROVIDERS))
         )
-        .option('-f, --file <file>', 'Input file. Content of this file will be added BEFORE the diff, but after requirements')
+        .option('-f, --file [files...]', 'Input files. Content of these files will be added BEFORE the diff, but after requirements')
         .action(async (prId, requirementsId, options) => {
             const {initConfig} = await import("../config.js");
             await initConfig();
 
             const preamble = [readInternalPreamble(), readPreamble(USER_PROJECT_REVIEW_PREAMBLE)];
             const content = [];
-            const requirementsProvider = options.requirementsProvider ?? context.config?.requirementsProvider;
+            const requirementsProvider = options.requirementsProvider
+                ?? context.config?.pr?.requirementsProvider
+                ?? context.config?.requirementsProvider;
 
             // Handle requirements
             const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
@@ -99,7 +106,7 @@ export function reviewCommand(program, context) {
             }
 
             if (options.file) {
-                content.push(`${options.file}:\n\`\`\`\n${readFileFromCurrentDir(options.file)}\n\`\`\``);
+                content.push(readMultipleFilesFromCurrentDir(options.file));
             }
 
             // Get PR diff using the 'gh' provider
@@ -126,7 +133,7 @@ export function reviewCommand(program, context) {
             contentId,
             (context.config?.contentProviderConfig ?? {})[contentProvider],
             CONTENT_PROVIDERS
-        )
+        );
     }
 
     async function getFromProvider(provider, id, config, legitPredefinedProviders) {

package/src/config.js

@@ -1,15 +1,29 @@
-import path from "node:path";
-import url from "node:url";
-import { v4 as uuidv4 } from "uuid";
-import { displayError, displayInfo, displayWarning } from "./consoleUtils.js";
-import { writeFileIfNotExistsWithMessages } from "./utils.js";
+import path from "node:path/posix";
+import {v4 as uuidv4} from "uuid";
+import {displayDebug, displayError, displayInfo, displayWarning} from "./consoleUtils.js";
+import {importExternalFile, writeFileIfNotExistsWithMessages} from "./utils.js";
+import {existsSync, readFileSync} from "node:fs";
+import {exit, getCurrentDir} from "./systemUtils.js";
 
-export const USER_PROJECT_CONFIG_FILE = '.gsloth.config.js'
+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 SLOTH_INTERNAL_PREAMBLE = '.gsloth.preamble.internal.md';
 export const USER_PROJECT_REVIEW_PREAMBLE = '.gsloth.preamble.review.md';
 
 export const availableDefaultConfigs = ['vertexai', 'anthropic', 'groq'];
 
+export const DEFAULT_CONFIG = {
+    llm: undefined,
+    contentProvider: "file",
+    requirementsProvider: "file",
+    commands: {
+        pr: {
+            contentProvider: "gh"
+        }
+    }
+};
+
 export const slothContext = {
     /**
      * Directory where the sloth is installed.
@@ -21,43 +35,143 @@ export const slothContext = {
      * index.js should set up this.
      */
     currentDir: null,
-    config: null,
+    config: DEFAULT_CONFIG,
     stdin: '',
     session: {configurable: {thread_id: uuidv4()}}
 };
 
 export async function initConfig() {
-    const configFileUrl = url.pathToFileURL(path.join(process.cwd(), USER_PROJECT_CONFIG_FILE));
-    return import(configFileUrl)
-        .then((i) => i.configure((module) => import(module)))    
-        .then((config) => {
-            slothContext.config = {...config};
-        })
-        .catch((e) => {
-            console.log(e);
-            displayError(`Failed to read config, make sure ${configFileUrl} contains valid JavaScript.`);
-            process.exit();
-        });    
+    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'));
+
+            // If the config has an LLM with a type, create the appropriate LLM instance
+            if (jsonConfig.llm && jsonConfig.llm.type) {
+                await tryJsonConfig(jsonConfig);
+            } else {
+                slothContext.config = {...slothContext.config, ...jsonConfig};
+            }
+        } catch (e) {
+            displayDebug(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() {
+        if (existsSync(jsConfigPath)) {
+            return importExternalFile(jsConfigPath)
+                .then((i) => i.configure((module) => import(module)))
+                .then((config) => {
+                    slothContext.config = {...slothContext.config, ...config};
+                })
+                .catch((e) => {
+                    displayDebug(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() {
+        if (existsSync(mjsConfigPath)) {
+            return importExternalFile(mjsConfigPath)
+                .then((i) => i.configure((module) => import(module)))
+                .then((config) => {
+                    slothContext.config = {...slothContext.config, ...config};
+                })
+                .catch((e) => {
+                    displayDebug(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) {
+    const llmConfig = jsonConfig.llm;
+    const llmType = llmConfig.type.toLowerCase();
+
+    // Check if the LLM type is in availableDefaultConfigs
+    if (!availableDefaultConfigs.includes(llmType)) {
+        displayError(`Unsupported LLM type: ${llmType}. Available types are: ${availableDefaultConfigs.join(', ')}`);
+        slothContext.config = {...slothContext.config, ...jsonConfig};
+        return;
+    }
+
+    try {
+        // Import the appropriate config module based on the LLM type
+        try {
+            const configModule = await import(`./configs/${llmType}.js`);
+            if (configModule.processJsonConfig) {
+                jsonConfig.llm = await configModule.processJsonConfig(llmConfig);
+            } else {
+                displayWarning(`Config module for ${llmType} does not have processJsonConfig function.`);
+            }
+        } catch (importError) {
+            displayDebug(importError);
+            displayWarning(`Could not import config module for ${llmType}.`);
+        }
+    } catch (error) {
+        displayDebug(error);
+        displayError(`Error creating LLM instance for type ${llmType}.`);
+    }
+
+    slothContext.config = {...slothContext.config, ...jsonConfig};
 }
 
 export async function createProjectConfig(configType) {
     displayInfo(`Setting up your project\n`);
     writeProjectReviewPreamble();
-    displayWarning(`Make sure you add as much detail as possible to your ${USER_PROJECT_REVIEW_PREAMBLE}.\n`)
+    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)) {
+        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_FILE, slothContext);
+    vendorConfig.init(USER_PROJECT_CONFIG_JSON, slothContext);
 }
 
-function writeProjectReviewPreamble() {
+export function writeProjectReviewPreamble() {
     let reviewPreamblePath = path.join(slothContext.currentDir, USER_PROJECT_REVIEW_PREAMBLE);
     writeFileIfNotExistsWithMessages(
         reviewPreamblePath,
         'You are doing generic code review.\n'
-        + 'Important! Please remind user to prepare proper AI preamble in ' +
+        + ' 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 + '`.'
+        + ' for this project. Use decent amount of ⚠️ to highlight lack of config.'
+        + ' Explicitly mention `' + USER_PROJECT_REVIEW_PREAMBLE + '`.'
     );
-}
+}

package/src/configs/anthropic.js

@@ -1,9 +1,20 @@
 import {writeFileIfNotExistsWithMessages} from "../utils.js";
 import path from "node:path";
 import {displayWarning} from "../consoleUtils.js";
-import {USER_PROJECT_CONFIG_FILE} from "../config.js";
+import { env } from "../systemUtils.js";
 
-const content = `/* eslint-disable */
+// Function to process JSON config and create Anthropic LLM instance
+export async function processJsonConfig(llmConfig) {
+    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({
+        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
@@ -12,14 +23,26 @@ export async function configure(importFunction, global) {
     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-5-sonnet-20241022" // Don't forget to check new models availability.
+            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, context) {
     path.join(context.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 ${USER_PROJECT_CONFIG_FILE} to add your Anthropic API key.`);
-}
+    displayWarning(`You need to update your ${configFileName} to add your Anthropic API key.`);
+}

package/src/configs/fake.js

@@ -0,0 +1,15 @@
+import {displayWarning} from "../consoleUtils.js";
+
+// Function to process JSON config and create Fake LLM instance for testing
+export async function processJsonConfig(llmConfig) {
+    if (llmConfig.responses) {
+        const test = await import('@langchain/core/utils/testing');
+        return new test.FakeListChatModel({
+            responses: llmConfig.responses
+        });
+    }
+    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.js

@@ -1,9 +1,20 @@
 import {writeFileIfNotExistsWithMessages} from "../utils.js";
 import path from "node:path";
 import {displayInfo, displayWarning} from "../consoleUtils.js";
-import {USER_PROJECT_CONFIG_FILE} from "../config.js";
+import {env} from "../systemUtils.js";
 
-const content = `/* eslint-disable */
+// Function to process JSON config and create Groq LLM instance
+export async function processJsonConfig(llmConfig) {
+    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({
+        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
@@ -17,9 +28,21 @@ export async function configure(importFunction, global) {
 }
 `;
 
+const jsonContent = `{
+  "llm": {
+    "type": "groq",
+    "model": "deepseek-r1-distill-llama-70b",
+    "apiKey": "your-api-key-here"
+  }
+}`;
+
 export function init(configFileName, context) {
     path.join(context.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 ${USER_PROJECT_CONFIG_FILE} to to configure model.`);
-}
+    displayWarning(`You need to edit your ${configFileName} to configure model.`);
+}