gaunt-sloth-assistant 0.1.1 → 0.1.3

package/spec/.gsloth.config.json

@@ -0,0 +1,25 @@
+{
+  "llm": {
+    "type": "fake",
+    "responses": ["First LLM message", "Second LLM message"]
+  },
+  "requirementsProviderConfig": {
+    "jira-legacy": {
+      "username": "user.name@company.com",
+      "token": "YoUrToKeN",
+      "baseUrl": "https://company.atlassian.net/rest/api/2/issue/"
+    }
+  },
+  "requirementsProvider": "file",
+  "contentProvider": "somethingSpecial",
+  "contentProviderConfig": {
+    "somethingSpecial": {
+      "test": "example"
+    }
+  },
+  "commands": {
+    "pr": {
+      "requirementsProvider": "jira-legacy"
+    }
+  }
+}

package/spec/askCommand.spec.js

@@ -4,13 +4,36 @@ import * as td from 'testdouble';
 describe('askCommand', function (){
 
     beforeEach(async function() {
+        td.reset();
         this.askQuestion = td.function();
         this.prompt = await td.replaceEsm("../src/prompt.js");
         td.when(this.prompt.readInternalPreamble()).thenReturn("INTERNAL PREAMBLE");
         this.questionAnsweringMock = await td.replaceEsm("../src/modules/questionAnsweringModule.js");
-        await td.replaceEsm("../src/config.js");
-        this.utils = await td.replaceEsm("../src/utils.js");
-        td.when(this.utils.readFileFromCurrentDir("test.file")).thenReturn("FILE CONTENT");
+        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 CONTENT");
+        td.when(this.utilsMock.readMultipleFilesFromCurrentDir(["test.file"])).thenReturn("test.file:\n```\nFILE CONTENT\n```");
         td.when(this.questionAnsweringMock.askQuestion(
             'sloth-ASK',
             td.matchers.anything(),
@@ -31,7 +54,17 @@ describe('askCommand', function (){
         const program = new Command();
         await askCommand(program, {});
         await program.parseAsync(['na', 'na', 'ask', 'test message', '-f', 'test.file']);
-        td.verify(this.askQuestion('sloth-ASK', "INTERNAL PREAMBLE", "test message\nFILE CONTENT"));
+        td.verify(this.askQuestion('sloth-ASK', "INTERNAL PREAMBLE", "test message\ntest.file:\n```\nFILE CONTENT\n```"));
+    });
+
+    it('Should call askQuestion with message and multiple file contents', async function() {
+        const { askCommand } = await import("../src/commands/askCommand.js");
+        const program = new Command();
+        await askCommand(program, {});
+        td.when(this.utilsMock.readMultipleFilesFromCurrentDir(["test.file", "test2.file"]))
+            .thenReturn("test.file:\n```\nFILE CONTENT\n```\n\ntest2.file:\n```\nFILE2 CONTENT\n```");
+        await program.parseAsync(['na', 'na', 'ask', 'test message', '-f', 'test.file', 'test2.file']);
+        td.verify(this.askQuestion('sloth-ASK', "INTERNAL PREAMBLE", "test message\ntest.file:\n```\nFILE CONTENT\n```\n\ntest2.file:\n```\nFILE2 CONTENT\n```"));
     });
 
     it('Should display help correctly', async function() {
@@ -47,6 +80,7 @@ describe('askCommand', function (){
         await askCommand(program, {});
 
         const commandUnderTest = program.commands.find(c => c.name() == 'ask');
+
         expect(commandUnderTest).toBeDefined();
         commandUnderTest.outputHelp();
 
@@ -55,4 +89,4 @@ describe('askCommand', function (){
         expect(testOutput.text).toContain('<message>');
         expect(testOutput.text).toContain('-f, --file');
     });
-});
+});

package/spec/config.spec.js

@@ -0,0 +1,421 @@
+import * as td from 'testdouble';
+
+describe('config', function () {
+
+    const ctx = {
+        consoleUtilsMock: {
+            display: td.function(),
+            displayError: td.function(),
+            displayInfo: td.function(),
+            displayWarning: td.function(),
+            displaySuccess: td.function(),
+            displayDebug: td.function()
+        },
+        fsMock: {
+            existsSync: td.function(),
+            readFileSync: td.function(),
+            writeFileSync: td.function(),
+            default: {
+                existsSync: td.function(),
+                readFileSync: td.function(),
+                writeFileSync: td.function()
+            }
+        },
+        urlMock: {
+            pathToFileURL: td.function(),
+            default: {
+                pathToFileURL: td.function()
+            }
+        },
+        utilsMock: {
+            writeFileIfNotExistsWithMessages: td.function(),
+            importExternalFile: td.function(),
+            importFromFilePath: td.function(),
+            ProgressIndicator: td.constructor(),
+            fileSafeLocalDate: td.function(),
+            toFileSafeString: td.function(),
+            extractLastMessageContent: td.function(),
+            readFileSyncWithMessages: td.function()
+        },
+        systemUtilsMock: {
+            exit: td.function(),
+            getCurrentDir: td.function(),
+            getInstallDir: td.function(),
+        }
+    };
+
+    beforeEach(async function () {
+
+        // Reset testdouble before each test
+        td.reset();
+
+        // Set up specific fs mocks - use td.matchers.contains to match any path containing the config file name
+        td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.json'))).thenReturn(false);
+        td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.js'))).thenReturn(false);
+        td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.mjs'))).thenReturn(false);
+
+        // Set up the same mocks for the default export of fs
+        td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.json'))).thenReturn(false);
+        td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.js'))).thenReturn(false);
+        td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.mjs'))).thenReturn(false);
+
+        // Set up specific url mocks - use Windows-style paths for file URLs
+        const jsonFileUrl = 'file:////mock/current/dir/.gsloth.config.json';
+        const jsFileUrl = 'file:////mock/current/dir/.gsloth.config.js';
+        const mjsFileUrl = 'file:////mock/current/dir/.gsloth.config.mjs';
+
+        td.when(ctx.urlMock.pathToFileURL('/mock/current/dir/.gsloth.config.json')).thenReturn(jsonFileUrl);
+        td.when(ctx.urlMock.pathToFileURL('/mock/current/dir/.gsloth.config.js')).thenReturn(jsFileUrl);
+        td.when(ctx.urlMock.pathToFileURL('/mock/current/dir/.gsloth.config.mjs')).thenReturn(mjsFileUrl);
+
+        // Set up the same mocks for the default export of url
+        td.when(ctx.urlMock.default.pathToFileURL('/mock/current/dir/.gsloth.config.json')).thenReturn(jsonFileUrl);
+        td.when(ctx.urlMock.default.pathToFileURL('/mock/current/dir/.gsloth.config.js')).thenReturn(jsFileUrl);
+        td.when(ctx.urlMock.default.pathToFileURL('/mock/current/dir/.gsloth.config.mjs')).thenReturn(mjsFileUrl);
+
+        td.when(ctx.systemUtilsMock.getInstallDir()).thenReturn("/mock/install/dir");
+        td.when(ctx.systemUtilsMock.getCurrentDir()).thenReturn("/mock/current/dir");
+
+        // Replace modules with mocks
+        await td.replaceEsm('node:fs', ctx.fsMock);
+        await td.replaceEsm('node:url', ctx.urlMock);
+        await td.replaceEsm('../src/consoleUtils.js', ctx.consoleUtilsMock);
+        await td.replaceEsm('./consoleUtils.js', ctx.consoleUtilsMock);
+        await td.replaceEsm('../src/utils.js', ctx.utilsMock);
+        await td.replaceEsm('../src/systemUtils.js', ctx.systemUtilsMock);
+        await td.replaceEsm('./systemUtils.js', ctx.systemUtilsMock);
+    });
+
+    describe('initConfig', function () {
+        it('Should load JSON config when it exists', async function () {
+            const jsonConfig = {llm: {type: 'vertexai'}};
+
+            td.when(
+                ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.json'))
+            ).thenReturn(true);
+            td.when(
+                ctx.fsMock.readFileSync(td.matchers.contains('.gsloth.config.json'), 'utf8')
+            ).thenReturn(JSON.stringify(jsonConfig));
+            td.when(
+                ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.json'))
+            ).thenReturn(true);
+            td.when(
+                ctx.fsMock.default.readFileSync(td.matchers.contains('.gsloth.config.json'), 'utf8')
+            ).thenReturn(JSON.stringify(jsonConfig));
+            await td.replaceEsm('../src/configs/vertexai.js', {});
+            const {initConfig, slothContext} = await import('../src/config.js');
+
+            // Function under test
+            await initConfig();
+
+            expect(slothContext.config).toEqual({
+                llm: {type: 'vertexai'},
+                contentProvider: 'file',
+                requirementsProvider: 'file',
+                commands: {pr: {contentProvider: 'gh'}}
+            });
+
+            td.verify(ctx.consoleUtilsMock.displayWarning(
+                "Config module for vertexai does not have processJsonConfig function."
+            ));
+            td.verify(ctx.consoleUtilsMock.displayDebug(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayError(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+
+        it('Should try JS config when JSON config does not exist', async function () {
+            td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.json'))).thenReturn(false);
+            td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.json'))).thenReturn(false);
+            td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.js'))).thenReturn(true);
+            td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.js'))).thenReturn(true);
+
+            // Mock the import function
+            const mockConfigModule = {
+                configure: td.function()
+            };
+            const mockConfig = {llm: {type: 'anthropic'}};
+            td.when(mockConfigModule.configure(td.matchers.anything())).thenResolve(mockConfig);
+
+            td.when(
+                ctx.utilsMock.importExternalFile(td.matchers.contains('.gsloth.config.js'))
+            ).thenResolve(mockConfigModule);
+
+            const {initConfig, slothContext} = await import('../src/config.js');
+
+            // Function under test
+            await initConfig();
+
+            expect(slothContext.config).toEqual({
+                llm: {type: 'anthropic'},
+                contentProvider: 'file',
+                requirementsProvider: 'file',
+                commands: {pr: {contentProvider: 'gh'}}
+            });
+            td.verify(ctx.consoleUtilsMock.displayDebug(
+                td.matchers.argThat((e) => String(e).includes("is not valid JSON")))
+            );
+            td.verify(ctx.consoleUtilsMock.displayError(
+                "Failed to read config from .gsloth.config.json, will try other formats."
+            ));
+            td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+
+        it('Should try MJS config when JSON and JS configs do not exist', async function () {
+            // Setup mocks for MJS config
+            td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.json'))).thenReturn(false);
+            td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.json'))).thenReturn(false);
+            td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.js'))).thenReturn(false);
+            td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.js'))).thenReturn(false);
+            td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.mjs'))).thenReturn(true);
+            td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.mjs'))).thenReturn(true);
+
+            const mockConfigModule = {
+                configure: td.function()
+            };
+            const mockConfig = {llm: {type: 'groq'}};
+            td.when(mockConfigModule.configure(td.matchers.anything())).thenResolve(mockConfig);
+
+            td.when(
+                ctx.utilsMock.importExternalFile(td.matchers.contains('.gsloth.config.mjs'))
+            ).thenResolve(mockConfigModule);
+
+            const {initConfig, slothContext} = await import('../src/config.js');
+
+            // Function under test
+            await initConfig();
+
+            expect(slothContext.config).toEqual({
+                llm: {type: 'groq'},
+                contentProvider: 'file',
+                requirementsProvider: 'file',
+                commands: {pr: {contentProvider: 'gh'}}
+            });
+            td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayDebug(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayError(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+
+        it('Should exit when no config files exist', async function () {
+            // Setup mocks for no config files
+            td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.json'))).thenReturn(false);
+            td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.json'))).thenReturn(false);
+            td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.js'))).thenReturn(false);
+            td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.js'))).thenReturn(false);
+            td.when(ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.mjs'))).thenReturn(false);
+            td.when(ctx.fsMock.default.existsSync(td.matchers.contains('.gsloth.config.mjs'))).thenReturn(false);
+
+            const {initConfig} = await import('../src/config.js');
+
+            // Function under test
+            await initConfig();
+
+            // Verify process.exit was called
+            td.verify(ctx.systemUtilsMock.exit());
+
+            // Verify no message was displayed
+            td.verify(ctx.consoleUtilsMock.displayError(
+                "No configuration file found. Please create one of: " +
+                ".gsloth.config.json, .gsloth.config.js, or .gsloth.config.mjs " +
+                "in your project directory."
+            ));
+            td.verify(ctx.consoleUtilsMock.displayDebug(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+    });
+
+    describe('processJsonLlmConfig', function () {
+        it('Should process valid LLM type', async function () {
+            // Create a test config
+            const jsonConfig = {
+                llm: {
+                    type: 'vertexai',
+                    model: 'test-model'
+                }
+            };
+            const processJsonConfig = td.function();
+            await td.replaceEsm('../src/configs/vertexai.js', {
+                processJsonConfig
+            });
+            td.when(processJsonConfig(jsonConfig.llm)).thenReturn(jsonConfig.llm);
+            const {tryJsonConfig, slothContext} = await import('../src/config.js');
+
+            // Call the function
+            await tryJsonConfig(jsonConfig);
+
+            // Verify the config was set correctly
+            expect(slothContext.config.llm.type).toBe('vertexai');
+
+            // Verify no message was displayed
+            td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayDebug(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayError(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+
+        it('Should handle invalid LLM type', async function () {
+            const jsonConfig = {
+                llm: {
+                    type: 'invalid-type',
+                    model: 'test-model'
+                }
+            };
+
+            const {tryJsonConfig, slothContext} = await import('../src/config.js');
+
+            // Function under test
+            await tryJsonConfig(jsonConfig);
+
+            expect(slothContext.config).toEqual({
+                llm: { type: 'invalid-type', model: 'test-model' },
+                contentProvider: 'file',
+                requirementsProvider: 'file',
+                commands: { pr: { contentProvider: 'gh' } }
+            });
+
+            td.verify(ctx.consoleUtilsMock.displayError(
+                "Unsupported LLM type: invalid-type. Available types are: vertexai, anthropic, groq"
+            ));
+            td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayDebug(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+
+        it('Should handle import errors', async function () {
+            const jsonConfig = {
+                llm: {
+                    type: 'vertexai',
+                    model: 'test-model'
+                }
+            };
+            const {tryJsonConfig, slothContext} = await import('../src/config.js');
+
+            await tryJsonConfig(jsonConfig);
+
+            expect(slothContext.config).toEqual({
+                llm: { type: 'vertexai', model: 'test-model' },
+                contentProvider: 'file',
+                requirementsProvider: 'file',
+                commands: { pr: { contentProvider: 'gh' } }
+            });
+
+
+            td.verify(ctx.consoleUtilsMock.displayWarning(
+                td.matchers.contains("Could not import config module for vertexai"))
+            );
+            td.verify(ctx.consoleUtilsMock.displayDebug(
+                td.matchers.argThat((e) => String(e).includes("Error: Unable to verify model params")))
+            );
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayError(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+    });
+
+    describe('createProjectConfig', function () {
+        it('Should create config for valid config type', async function () {
+            const {createProjectConfig, slothContext} = await import('../src/config.js');
+
+            slothContext.currentDir = '/mock/current/dir/';
+
+            // Function under test
+            await createProjectConfig('vertexai');
+
+            td.verify(ctx.utilsMock.writeFileIfNotExistsWithMessages(
+                "/mock/current/dir/.gsloth.preamble.review.md",
+                td.matchers.contains(
+                    "You are doing generic code review.\n" +
+                    " Important! Please remind user to prepare proper AI preamble in.gsloth.preamble.review.md" +
+                    " for this project. Use decent amount of ⚠️ to highlight lack of config." +
+                    " Explicitly mention `.gsloth.preamble.review.md`."
+                )
+            ));
+
+            td.verify(ctx.utilsMock.writeFileIfNotExistsWithMessages(
+                ".gsloth.config.json",
+                td.matchers.contains(`"type": "vertexai"`)
+            ));
+
+            td.verify(ctx.consoleUtilsMock.displayInfo(
+                td.matchers.contains("Setting up your project")
+            ), {times: 1});
+            td.verify(ctx.consoleUtilsMock.displayInfo(
+                td.matchers.contains("Creating project config for vertexai")
+            ), {times: 1});
+            td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.contains(
+                "Make sure you add as much detail as possible to your .gsloth.preamble.review.md."
+            )));
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayError(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayDebug(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+
+        it('Should handle invalid config type', async function () {
+            const {createProjectConfig, slothContext} = await import('../src/config.js');
+            slothContext.currentDir = '/mock/current/dir/';
+
+            // Function under test
+            await createProjectConfig('invalid-type');
+
+            td.verify(ctx.systemUtilsMock.exit(1));
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.contains(
+                "Setting up your project"
+            )));
+            td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.contains(
+                "Make sure you add as much detail as possible to your .gsloth.preamble.review.md."
+            )));
+            td.verify(ctx.consoleUtilsMock.displayError(td.matchers.contains(
+                "Unsupported config type: invalid-type. Available types are: vertexai, anthropic, groq"
+            )));
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayDebug(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+    });
+
+    describe('writeProjectReviewPreamble', function () {
+        it('Should write project review preamble', async function () {
+            // Create a mock for writeFileIfNotExistsWithMessages
+            const writeFileIfNotExistsWithMessagesMock = td.function();
+
+            // Update the utils mock with our mock
+            ctx.utilsMock.writeFileIfNotExistsWithMessages = writeFileIfNotExistsWithMessagesMock;
+
+            const {writeProjectReviewPreamble, slothContext} = await import('../src/config.js');
+
+            slothContext.currentDir = '/mock/current/dir/';
+
+            // Call the function
+            writeProjectReviewPreamble();
+
+            // Verify writeFileIfNotExistsWithMessages was called with the correct arguments
+            td.verify(writeFileIfNotExistsWithMessagesMock(
+                '/mock/current/dir/.gsloth.preamble.review.md',
+                td.matchers.anything()
+            ));
+
+            td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayDebug(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.display(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayError(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displayInfo(td.matchers.anything()), {times: 0});
+            td.verify(ctx.consoleUtilsMock.displaySuccess(td.matchers.anything()), {times: 0});
+        });
+    });
+});

package/spec/initCommand.spec.js

@@ -4,6 +4,7 @@ import * as td from 'testdouble';
 describe('initCommand', function (){
 
     beforeEach(async function() {
+        td.reset();
         // Create a mock for createProjectConfig
         this.createProjectConfig = td.function();
 
@@ -13,7 +14,6 @@ describe('initCommand', function (){
             availableDefaultConfigs: ['vertexai', 'anthropic', 'groq'],
             SLOTH_INTERNAL_PREAMBLE: '.gsloth.preamble.internal.md',
             USER_PROJECT_REVIEW_PREAMBLE: '.gsloth.preamble.review.md',
-            USER_PROJECT_CONFIG_FILE: '.gsloth.config.js',
             slothContext: {
                 installDir: '/mock/install/dir',
                 currentDir: '/mock/current/dir',
@@ -43,7 +43,8 @@ describe('initCommand', function (){
 
         await initCommand(program, {});
 
-        const commandUnderTest = program.commands.find(c => c.name() == 'init');
+        const commandUnderTest = program.commands.find(c => c.name() === 'init');
+
         expect(commandUnderTest).toBeDefined();
         commandUnderTest.outputHelp();
 

package/spec/predefinedConfigs.spec.js

@@ -0,0 +1,100 @@
+import * as td from "testdouble";
+
+
+describe('predefined AI provider configurations', function () {
+
+    const ctx = {
+        consoleUtilsMock: {
+            display: td.function(),
+            displayError: td.function(),
+            displayInfo: td.function(),
+            displayWarning: td.function(),
+            displaySuccess: td.function(),
+            displayDebug: td.function()
+        },
+        fsMock: {
+            existsSync: td.function(),
+            readFileSync: td.function(),
+            writeFileSync: td.function(),
+            default: {
+                existsSync: td.function(),
+                readFileSync: td.function(),
+                writeFileSync: td.function()
+            }
+        }
+    };
+
+    beforeEach(async function () {
+        td.reset();
+        await td.replaceEsm('node:fs', ctx.fsMock);
+        await td.replaceEsm('../src/consoleUtils.js', ctx.consoleUtilsMock);
+        await td.replaceEsm('./consoleUtils.js', ctx.consoleUtilsMock);
+    });
+
+    it('Should import predefined Anthropic config correctly', async function () {
+        // Mock the Anthropic module and its import
+        const mockChat = td.constructor();
+        const mockChatInstance = {};
+        td.when(mockChat(td.matchers.anything())).thenReturn(mockChatInstance);
+        await td.replaceEsm('@langchain/anthropic', {
+            ChatAnthropic: mockChat
+        });
+
+        await testPredefinedAiConfig('anthropic', mockChatInstance);
+    });
+
+    it('Should import predefined VertexAI config correctly', async function () {
+        // Mock the Anthropic module and its import
+        const mockChat = td.constructor();
+        const mockChatInstance = {};
+        td.when(mockChat(td.matchers.anything())).thenReturn(mockChatInstance);
+        await td.replaceEsm('@langchain/google-vertexai', {
+            ChatVertexAI: mockChat
+        });
+
+        await testPredefinedAiConfig('vertexai', mockChatInstance);
+    });
+
+    it('Should import predefined Groq config correctly', async function () {
+        // Mock the Anthropic module and its import
+        const mockChat = td.constructor();
+        const mockChatInstance = {};
+        td.when(mockChat(td.matchers.anything())).thenReturn(mockChatInstance);
+        await td.replaceEsm('@langchain/groq', {
+            ChatGroq: mockChat
+        });
+
+        await testPredefinedAiConfig('groq', mockChatInstance);
+    });
+
+    async function testPredefinedAiConfig(aiProvider, mockAnthropicInstance) {
+        const jsonConfig = {
+            llm: {
+                type: aiProvider,
+                model: 'claude-3-5-sonnet-20241022',
+                apiKey: 'test-api-key'
+            }
+        };
+
+        td.when(
+            ctx.fsMock.existsSync(td.matchers.contains('.gsloth.config.json'))
+        ).thenReturn(true);
+
+        td.when(
+            ctx.fsMock.readFileSync(td.matchers.contains('.gsloth.config.json'), 'utf8')
+        ).thenReturn(JSON.stringify(jsonConfig));
+
+        const {initConfig, slothContext} = await import('../src/config.js');
+
+        // Call the function
+        await initConfig(jsonConfig);
+
+        // Verify the config was set correctly with the mock instance
+        expect(slothContext.config.llm).toBe(mockAnthropicInstance);
+
+        // Verify no warnings or errors were displayed
+        td.verify(ctx.consoleUtilsMock.displayWarning(td.matchers.anything()), {times: 0});
+        td.verify(ctx.consoleUtilsMock.displayError(td.matchers.anything()), {times: 0});
+    }
+
+});