genaicode 0.0.31 → 0.0.33

package/src/images/resize-image.js

@@ -0,0 +1,23 @@
+import sharp from 'sharp';
+import fs from 'fs';
+
+/**
+ *
+ * @param {Buffer} input
+ * @param {{width: number, height: number}} size
+ * @returns {Buffer}
+ */
+export async function resizeImageBuffer(input, size) {
+  return await sharp(input).resize(size.width, size.height).toBuffer();
+}
+
+/**
+ *
+ * @param {string} filePath
+ * @param {{width: number, height: number}} size
+ * @returns {Buffer}
+ */
+export async function resizeImageFile(filePath, size) {
+  const buffer = await resizeImageBuffer(filePath, size);
+  fs.writeFileSync(filePath, buffer);
+}

package/src/images/split-image.js

@@ -0,0 +1,26 @@
+import sharp from 'sharp';
+
+/**
+ * This function opens the input file, and splits its into parts, extracting parts of the input image, and saving to outputFilePaths
+ *
+ * @param {string} inputFilePath
+ * @param {Array<{rect: {x: number, y: number, width: number, height: number}, outputFilePath: string}>} parts
+ */
+export async function splitImage(inputFilePath, parts) {
+  try {
+    // Process each part
+    for (const part of parts) {
+      const { rect, outputFilePath } = part;
+      const { x, y, width, height } = rect;
+
+      // Extract the specified rectangle from the input image
+      console.log('Extracting', rect, outputFilePath);
+      await sharp(inputFilePath).extract({ left: x, top: y, width, height }).toFile(outputFilePath);
+    }
+
+    console.log('Image splitting completed successfully.');
+  } catch (error) {
+    console.error('Error splitting image:', error);
+    throw error;
+  }
+}

package/src/main/codegen.js

@@ -10,15 +10,19 @@ import {
   vertexAiClaude,
   disableInitialLint,
   helpRequested,
+  imagen,
 } from '../cli/cli-params.js';
 import { validateCliParams } from '../cli/validate-cli-params.js';
 import { generateContent as generateContentVertexAi } from '../ai-service/vertex-ai.js';
 import { generateContent as generateContentGPT } from '../ai-service/chat-gpt.js';
 import { generateContent as generateContentAnthropic } from '../ai-service/anthropic.js';
 import { generateContent as generateContentVertexAiClaude } from '../ai-service/vertex-ai-claude.js';
+import { generateImage as generateImageDallE } from '../ai-service/dall-e.js';
+import { generateImage as generateImageVertexAi } from '../ai-service/vertex-ai-imagen.js';
+
 import { promptService } from '../prompt/prompt-service.js';
 import { updateFiles } from '../files/update-files.js';
-import { rcConfig } from '../files/find-files.js';
+import { rcConfig } from '../main/config.js';
 import { getLintFixPrompt } from '../prompt/prompt-codegen.js';
 import { printHelpMessage } from '../cli/cli-options.js';
 
@@ -63,8 +67,11 @@ export async function runCodegen() {
           ? generateContentGPT
           : assert(false, 'Please specify which AI service should be used');
 
+  const generateImage =
+    imagen === 'vertex-ai' ? generateImageVertexAi : imagen === 'dall-e' ? generateImageDallE : undefined;
+
   console.log('Generating response');
-  let functionCalls = await promptService(generateContent);
+  let functionCalls = await promptService(generateContent, generateImage);
   console.log('Received function calls:', functionCalls);
 
   if (dryRun) {
@@ -87,7 +94,7 @@ export async function runCodegen() {
         const lintErrorPrompt = getLintFixPrompt(rcConfig.lintCommand, error.stdout, error.stderr);
 
         console.log('Generating response for lint fixes');
-        const lintFixFunctionCalls = await promptService(generateContent, lintErrorPrompt);
+        const lintFixFunctionCalls = await promptService(generateContent, generateImage, lintErrorPrompt);
 
         console.log('Received function calls for lint fixes:', lintFixFunctionCalls);
 

package/src/main/codegen.test.js

@@ -10,6 +10,9 @@ import * as updateFiles from '../files/update-files.js';
 import '../files/find-files.js';
 import * as cliParams from '../cli/cli-params.js';
 import * as cliOptions from '../cli/cli-options.js';
+import * as vertexAiImagen from '../ai-service/vertex-ai-imagen.js';
+import * as dallE from '../ai-service/dall-e.js';
+import './config.js';
 
 vi.mock('../ai-service/vertex-ai.js', () => ({ generateContent: vi.fn() }));
 vi.mock('../ai-service/chat-gpt.js', () => ({ generateContent: vi.fn() }));
@@ -31,19 +34,26 @@ vi.mock('../cli/cli-params.js', () => ({
   vision: false,
   imagen: false,
   temperature: 0.7,
+  cheap: false,
+  taskFile: undefined,
+  disableInitialLint: undefined,
 }));
 vi.mock('../files/find-files.js', () => ({
-  rootDir: '/mocked/root/dir',
-  rcConfig: {
-    rootDir: '.',
-    extensions: ['.js', '.ts', '.tsx', '.jsx'],
-  },
   getSourceFiles: () => [],
   getImageAssetFiles: () => [],
 }));
 vi.mock('../cli/cli-options.js', () => ({
   printHelpMessage: vi.fn(),
 }));
+vi.mock('../ai-service/vertex-ai-imagen.js', () => ({ generateImage: vi.fn() }));
+vi.mock('../ai-service/dall-e.js', () => ({ generateImage: vi.fn() }));
+vi.mock('./config.js', () => ({
+  rootDir: '/mocked/root/dir',
+  rcConfig: {
+    rootDir: '.',
+    extensions: ['.js', '.ts', '.tsx', '.jsx'],
+  },
+}));
 
 describe('runCodegen', () => {
   beforeEach(() => {
@@ -55,6 +65,7 @@ describe('runCodegen', () => {
     cliParams.dryRun = false;
     cliParams.helpRequested = false;
     cliParams.vision = false;
+    cliParams.imagen = false;
   });
 
   it('should run codegen with Vertex AI by default', async () => {
@@ -135,7 +146,13 @@ describe('runCodegen', () => {
 
     await runCodegen();
 
-    expect(vertexAi.generateContent).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), 0.5);
+    expect(vertexAi.generateContent).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      0.5,
+      false,
+    );
     expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
   });
 
@@ -183,4 +200,135 @@ describe('runCodegen', () => {
       ]),
     );
   });
+
+  it('should use Vertex AI Imagen when imagen flag is set to vertex-ai', async () => {
+    cliParams.imagen = 'vertex-ai';
+    cliParams.vertexAi = true;
+
+    const mockCodegenSummary = [
+      {
+        name: 'codegenSummary',
+        args: {
+          files: [{ path: 'test.js', updateToolName: 'updateFile' }],
+          contextPaths: [],
+          explanation: 'Mock summary with image generation failure',
+        },
+      },
+    ];
+    const mockFunctionCalls = [
+      { name: 'generateImage', args: { prompt: 'A beautiful landscape', filePath: 'landscape.png', size: '512x512' } },
+    ];
+    vertexAi.generateContent.mockResolvedValueOnce(mockCodegenSummary);
+    vertexAi.generateContent.mockResolvedValueOnce(mockFunctionCalls);
+    vertexAiImagen.generateImage.mockResolvedValueOnce('mocked-image-data');
+
+    await runCodegen();
+
+    expect(vertexAi.generateContent).toHaveBeenCalled();
+    expect(vertexAiImagen.generateImage).toHaveBeenCalledWith('A beautiful landscape', undefined, '512x512', false);
+    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
+  });
+
+  it('should use DALL-E when imagen flag is set to dall-e', async () => {
+    cliParams.imagen = 'dall-e';
+    cliParams.chatGpt = true;
+
+    const mockCodegenSummary = [
+      {
+        name: 'codegenSummary',
+        args: {
+          files: [{ path: 'test.js', updateToolName: 'updateFile' }],
+          contextPaths: [],
+          explanation: 'Mock summary with image generation failure',
+        },
+      },
+    ];
+    const mockFunctionCalls = [
+      { name: 'generateImage', args: { prompt: 'A futuristic city', filePath: 'city.png', size: '1024x1024' } },
+    ];
+    chatGpt.generateContent.mockResolvedValueOnce(mockCodegenSummary);
+    chatGpt.generateContent.mockResolvedValueOnce(mockFunctionCalls);
+    dallE.generateImage.mockResolvedValueOnce('mocked-image-data');
+
+    await runCodegen();
+
+    expect(chatGpt.generateContent).toHaveBeenCalled();
+    expect(dallE.generateImage).toHaveBeenCalledWith('A futuristic city', undefined, '1024x1024', false);
+    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
+  });
+
+  it('should throw an error when imagen flag is set but no AI service is specified', async () => {
+    cliParams.imagen = 'vertex-ai';
+
+    await expect(runCodegen()).rejects.toThrow('Please specify which AI service should be used');
+  });
+
+  it('should pass the cheap parameter to the AI service when --cheap flag is true', async () => {
+    cliParams.vertexAi = true;
+    cliParams.cheap = true;
+
+    const mockFunctionCalls = [
+      { name: 'updateFile', args: { filePath: 'test.js', newContent: 'console.log("Cheap test");' } },
+    ];
+    vertexAi.generateContent.mockResolvedValueOnce(mockFunctionCalls);
+
+    await runCodegen();
+
+    expect(vertexAi.generateContent).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      true,
+    );
+    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
+  });
+
+  it('should pass the cheap parameter to the image generation service when --cheap flag is true', async () => {
+    cliParams.imagen = 'vertex-ai';
+    cliParams.vertexAi = true;
+    cliParams.cheap = true;
+
+    const mockCodegenSummary = [
+      {
+        name: 'codegenSummary',
+        args: {
+          files: [{ path: 'test.js', updateToolName: 'updateFile' }],
+          contextPaths: [],
+          explanation: 'Mock summary with cheap image generation',
+        },
+      },
+    ];
+    const mockFunctionCalls = [
+      {
+        name: 'generateImage',
+        args: {
+          prompt: 'A simple landscape',
+          filePath: 'landscape.png',
+          size: { width: 256, height: 256 },
+          cheap: true,
+        },
+      },
+    ];
+    vertexAi.generateContent.mockResolvedValueOnce(mockCodegenSummary);
+    vertexAi.generateContent.mockResolvedValueOnce(mockFunctionCalls);
+    vertexAiImagen.generateImage.mockResolvedValueOnce('mocked-cheap-image-data');
+
+    await runCodegen();
+
+    expect(vertexAi.generateContent).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      true,
+    );
+    expect(vertexAiImagen.generateImage).toHaveBeenCalledWith(
+      'A simple landscape',
+      undefined,
+      { width: 256, height: 256 },
+      true,
+    );
+    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
+  });
 });

package/src/main/config-lib.js

@@ -0,0 +1,33 @@
+import fs from 'fs';
+import path from 'path';
+import assert from 'node:assert';
+
+import { isAncestorDirectory } from '../files/file-utils.js';
+
+// This file contains project codegen configuration
+const CODEGENRC_FILENAME = '.genaicoderc';
+
+// Find .genaicoderc file
+export function findRcFile() {
+  let rcFilePath = process.cwd();
+  while (!fs.existsSync(path.join(rcFilePath, CODEGENRC_FILENAME))) {
+    const parentDir = path.dirname(rcFilePath);
+    if (parentDir === rcFilePath) {
+      throw new Error(`${CODEGENRC_FILENAME} not found in any parent directory`);
+    }
+    rcFilePath = parentDir;
+  }
+  return path.join(rcFilePath, CODEGENRC_FILENAME);
+}
+
+// Read and parse .genaicoderc file
+export function parseRcFile(rcFilePath) {
+  assert(fs.existsSync(rcFilePath), `${CODEGENRC_FILENAME} not found`);
+  const rcConfig = JSON.parse(fs.readFileSync(rcFilePath, 'utf-8'));
+  assert(rcConfig.rootDir, 'Root dir not configured');
+
+  const rootDir = path.resolve(path.dirname(rcFilePath), rcConfig.rootDir);
+  assert(isAncestorDirectory(path.dirname(rcFilePath), rootDir), 'Root dir is not located inside project directory');
+
+  return { ...rcConfig, rootDir };
+}

package/src/main/config-lib.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { isAncestorDirectory } from '../files/file-utils.js';
+import { findRcFile, parseRcFile } from './config-lib';
+
+vi.mock('fs');
+vi.mock('path');
+vi.mock('../files/file-utils.js');
+
+const CODEGENRC_FILENAME = '.genaicoderc';
+
+// Mock data
+const mockRcContent = JSON.stringify({ rootDir: 'src' });
+const mockRootDir = '/project/src';
+const mockRcFilePath = `/project/${CODEGENRC_FILENAME}`;
+
+// Helper function to mock fs.existsSync
+function mockExistsSync(paths) {
+  return (p) => paths.includes(p);
+}
+
+// Tests
+
+// Test for findRcFile
+describe('findRcFile', () => {
+  it('should find .genaicoderc in the current or parent directories', () => {
+    fs.existsSync.mockImplementation(mockExistsSync([mockRcFilePath]));
+    path.dirname.mockImplementation((p) => (p === '/project' ? '/' : '/project'));
+    path.join.mockImplementation((...args) => args.join('/'));
+
+    const result = findRcFile();
+    expect(result).toBe(mockRcFilePath);
+  });
+
+  it('should throw an error if .genaicoderc is not found', () => {
+    fs.existsSync.mockReturnValue(false);
+    path.dirname.mockImplementation((p) => (p === '/' ? '/' : '/project'));
+
+    expect(() => findRcFile()).toThrowError(`${CODEGENRC_FILENAME} not found in any parent directory`);
+  });
+});
+
+// Test for parseRcFile
+describe('parseRcFile', () => {
+  it('should parse .genaicoderc and return config with rootDir', () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(mockRcContent);
+    path.resolve.mockImplementation((...args) => args.join('/'));
+    path.dirname.mockReturnValue('/project');
+    isAncestorDirectory.mockReturnValue(true);
+
+    const result = parseRcFile(mockRcFilePath);
+    expect(result).toEqual({ ...JSON.parse(mockRcContent), rootDir: mockRootDir });
+  });
+
+  it('should throw an error if .genaicoderc is missing', () => {
+    fs.existsSync.mockReturnValue(false);
+
+    expect(() => parseRcFile(mockRcFilePath)).toThrowError(`${CODEGENRC_FILENAME} not found`);
+  });
+
+  it('should throw an error if rootDir is not configured', () => {
+    const invalidContent = JSON.stringify({});
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(invalidContent);
+
+    expect(() => parseRcFile(mockRcFilePath)).toThrowError('Root dir not configured');
+  });
+
+  it('should throw an error if rootDir is not located inside project directory', () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(mockRcContent);
+    path.resolve.mockImplementation((...args) => args.join('/'));
+    path.dirname.mockReturnValue('/project');
+    isAncestorDirectory.mockReturnValue(false);
+
+    expect(() => parseRcFile(mockRcFilePath)).toThrowError('Root dir is not located inside project directory');
+  });
+});

package/src/main/config.js

@@ -0,0 +1,39 @@
+import { findRcFile, parseRcFile } from './config-lib.js';
+
+// Default extensions if not specified in .genaicoderc
+const DEFAULT_EXTENSIONS = [
+  '.md',
+  '.js',
+  '.ts',
+  '.tsx',
+  '.css',
+  '.scss',
+  '.py',
+  '.go',
+  '.c',
+  '.h',
+  '.cpp',
+  '.txt',
+  '.html',
+  '.txt',
+  '.json',
+];
+
+// A list of paths that are ignored by default
+const DEFAULT_IGNORE_PATHS = ['node_modules', 'build', 'dist', 'package-lock.json', 'coverage'];
+
+// Read and parse the configuration
+const rcFilePath = findRcFile();
+export const rcConfig = parseRcFile(rcFilePath);
+
+// Use extensions from .genaicoderc if available, otherwise use default
+export const sourceExtensions = rcConfig.extensions || DEFAULT_EXTENSIONS;
+
+// Image extensions (driven by ai service limitations)
+export const IMAGE_ASSET_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp'];
+
+// Export ignore paths
+export const ignorePaths = rcConfig.ignorePaths ?? DEFAULT_IGNORE_PATHS;
+
+console.log('Detected codegen configuration', rcConfig);
+console.log('Root dir:', rcConfig.rootDir);

package/src/prompt/prompt-codegen.js

@@ -23,7 +23,7 @@ export function getCodeGenPrompt() {
     codeGenFiles = Object.keys(getSourceCode());
   } else {
     codeGenFiles = Object.entries(getSourceCode())
-      .filter(([, content]) => content.match(new RegExp("([^'^`]+)" + CODEGEN_TRIGGER)))
+      .filter(([, { content }]) => content?.match(new RegExp("([^'^`]+)" + CODEGEN_TRIGGER)))
       .map(([path]) => path);
   }
 

package/src/prompt/prompt-service.js

@@ -7,11 +7,10 @@ import { getSystemPrompt } from './systemprompt.js';
 import { getCodeGenPrompt } from './prompt-codegen.js';
 import { functionDefs } from '../ai-service/function-calling.js';
 import { getSourceCode, getImageAssets } from '../files/read-files.js';
-import { disableContextOptimization, temperature, vision, imagen } from '../cli/cli-params.js';
-import { generateImage } from '../ai-service/dall-e.js';
+import { disableContextOptimization, temperature, vision, cheap } from '../cli/cli-params.js';
 
 /** A function that communicates with model using */
-export async function promptService(generateContentFn, codegenPrompt = getCodeGenPrompt()) {
+export async function promptService(generateContentFn, generateImageFn, codegenPrompt = getCodeGenPrompt()) {
   const messages = prepareMessages(codegenPrompt);
 
   // First stage: generate code generation summary, which should not take a lot of output tokens
@@ -44,7 +43,7 @@ export async function promptService(generateContentFn, codegenPrompt = getCodeGe
 
   prompt.slice(-1)[0].text = messages.prompt;
 
-  let baseResult = await generateContentFn(prompt, functionDefs, 'codegenSummary', temperature);
+  let baseResult = await generateContentFn(prompt, functionDefs, 'codegenSummary', temperature, cheap);
 
   const codegenSummaryRequest = baseResult.find((call) => call.name === 'codegenSummary');
 
@@ -82,6 +81,7 @@ export async function promptService(generateContentFn, codegenPrompt = getCodeGe
       console.log('Collecting partial update for: ' + file.path + ' using tool: ' + file.updateToolName);
       console.log('- Prompt:', file.prompt);
       console.log('- Temperature', file.temperature);
+      console.log('- Cheap', file.cheap);
       if (vision) {
         console.log('- Context image assets', file.contextImageAssets);
       }
@@ -106,6 +106,7 @@ export async function promptService(generateContentFn, codegenPrompt = getCodeGe
         functionDefs,
         file.updateToolName,
         file.temperature ?? temperature,
+        file.cheap === true,
       );
 
       let getSourceCodeCall = partialResult.find((call) => call.name === 'getSourceCode');
@@ -114,12 +115,12 @@ export async function promptService(generateContentFn, codegenPrompt = getCodeGe
       // Handle image generation requests
       const generateImageCall = partialResult.find((call) => call.name === 'generateImage');
       if (generateImageCall) {
-        assert(imagen, 'Image generation requested, but --imagen option not provided');
+        assert(!!generateImageFn, 'Image generation requested, but a image generation service was not provided');
 
         console.log('Processing image generation request:', generateImageCall.args);
         try {
-          const { prompt: imagePrompt, filePath, size } = generateImageCall.args;
-          const generatedImageUrl = await generateImage(imagePrompt, size);
+          const { prompt: imagePrompt, filePath, contextImagePath, size, cheap } = generateImageCall.args;
+          const generatedImageUrl = await generateImageFn(imagePrompt, contextImagePath, size, cheap === true);
 
           // Add a createFile call to the result to ensure the generated image is tracked
           partialResult.push({
@@ -161,7 +162,13 @@ export async function promptService(generateContentFn, codegenPrompt = getCodeGe
           console.log(`Patch could not be applied for ${filePath}. Retrying without patchFile function.`);
 
           // Rerun content generation without patchFile function
-          partialResult = await generateContentFn(prompt, functionDefs, 'updateFile', temperature);
+          partialResult = await generateContentFn(
+            prompt,
+            functionDefs,
+            'updateFile',
+            file.temperature,
+            file.cheap === true,
+          );
 
           let getSourceCodeCall = partialResult.find((call) => call.name === 'getSourceCode');
           assert(!getSourceCodeCall, 'Unexpected getSourceCode: ' + JSON.stringify(getSourceCodeCall));
@@ -200,7 +207,9 @@ function prepareMessages(prompt) {
     requestSourceCode: 'Please provide application source code.',
     suggestImageAssets: 'I should also provide you with a summary of application image assets',
     requestImageAssets: 'Please provide summary of application image assets.',
-    prompt: prompt + '\n Start from generating codegen summary, this summary will be used to generate updates.',
+    prompt:
+      prompt +
+      '\n Start from generating codegen summary, this summary will be used as a context to generate updates, so make sure that it contains useful information.',
     sourceCode: JSON.stringify(getSourceCode()),
     contextSourceCode: (paths) => JSON.stringify(getSourceCode(paths)),
     imageAssets: JSON.stringify(getImageAssets()),

package/src/prompt/prompt-service.test.js

@@ -30,6 +30,7 @@ vi.mock('../cli/cli-params.js', () => ({
   vision: false,
   imagen: false,
   temperature: 0.7,
+  cheap: false,
 }));
 vi.mock('fs');
 vi.mock('diff');
@@ -38,11 +39,6 @@ vi.mock('../ai-service/dall-e.js', () => ({ generateImage: vi.fn() }));
 
 // Mock find-files module
 vi.mock('../files/find-files.js', () => ({
-  rootDir: '/mocked/root/dir',
-  rcConfig: {
-    rootDir: '.',
-    extensions: ['.js', '.ts', '.tsx', '.jsx'],
-  },
   getSourceFiles: () => [],
   getImageAssetFiles: () => [],
 }));
@@ -53,6 +49,14 @@ vi.mock('../files/read-files.js', () => ({
   getImageAssets: vi.fn(() => ({})),
 }));
 
+vi.mock('../main/config.js', () => ({
+  rootDir: '/mocked/root/dir',
+  rcConfig: {
+    rootDir: '.',
+    extensions: ['.js', '.ts', '.tsx', '.jsx'],
+  },
+}));
+
 describe('promptService', () => {
   beforeEach(() => {
     vi.resetAllMocks();
@@ -394,7 +398,7 @@ describe('promptService', () => {
         args: {
           prompt: 'A test image',
           filePath: '/path/to/generated/image.png',
-          size: '256x256',
+          size: { width: 256, height: 256 },
         },
       },
     ];
@@ -413,10 +417,15 @@ describe('promptService', () => {
     vertexAi.generateContent.mockResolvedValueOnce(mockGenerateImageCall);
     dalleService.generateImage.mockResolvedValue('https://example.com/generated-image.png');
 
-    const result = await promptService(vertexAi.generateContent);
+    const result = await promptService(vertexAi.generateContent, dalleService.generateImage);
 
     expect(vertexAi.generateContent).toHaveBeenCalledTimes(2);
-    expect(dalleService.generateImage).toHaveBeenCalledWith('A test image', '256x256');
+    expect(dalleService.generateImage).toHaveBeenCalledWith(
+      'A test image',
+      undefined,
+      { width: 256, height: 256 },
+      false,
+    );
     expect(result).toEqual(expect.arrayContaining(mockDownloadFileCall));
   });
 
@@ -439,7 +448,7 @@ describe('promptService', () => {
         args: {
           prompt: 'A test image',
           filePath: '/path/to/generated/image.png',
-          size: '256x256',
+          size: { width: 256, height: 256 },
         },
       },
     ];
@@ -448,10 +457,15 @@ describe('promptService', () => {
     vertexAi.generateContent.mockResolvedValueOnce(mockGenerateImageCall);
     dalleService.generateImage.mockRejectedValue(new Error('Image generation failed'));
 
-    const result = await promptService(vertexAi.generateContent);
+    const result = await promptService(vertexAi.generateContent, dalleService.generateImage);
 
     expect(vertexAi.generateContent).toHaveBeenCalledTimes(2);
-    expect(dalleService.generateImage).toHaveBeenCalledWith('A test image', '256x256');
+    expect(dalleService.generateImage).toHaveBeenCalledWith(
+      'A test image',
+      undefined,
+      { width: 256, height: 256 },
+      false,
+    );
     expect(result).toEqual(
       expect.arrayContaining([
         expect.objectContaining({

package/src/prompt/systemprompt.js

@@ -1,7 +1,7 @@
 import { CODEGEN_TRIGGER } from './prompt-consts.js';
 import { verbosePrompt } from '../cli/cli-params.js';
 import { verifySystemPromptLimit } from './limits.js';
-import { rootDir } from '../files/find-files.js';
+import { rcConfig } from '../main/config.js';
 
 /** Generates a system prompt */
 export function getSystemPrompt() {
@@ -16,7 +16,7 @@ export function getSystemPrompt() {
 
   You should parse my application source code and then suggest changes using appropriate tools.
 
-  The root directory of my application is \`${rootDir}\` and you should limit the changes only to this path.
+  The root directory of my application is \`${rcConfig.rootDir}\` and you should limit the changes only to this path.
 
   When suggesting changes always use absolute file paths.
   `;

package/src/prompt/systemprompt.test.js

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { getSystemPrompt } from './systemprompt.js';
 import * as cliParams from '../cli/cli-params.js';
 import '../files/find-files.js';
+import '../main/config.js';
 
 vi.mock('../cli/cli-params.js', () => ({
   requireExplanations: false,
@@ -16,11 +17,13 @@ vi.mock('../cli/cli-params.js', () => ({
 }));
 
 vi.mock('../files/find-files.js', () => ({
-  rcConfig: {},
-  rootDir: '/mocked/root/dir',
   getSourceFiles: vi.fn(),
 }));
 
+vi.mock('../main/config.js', () => ({
+  rcConfig: { rootDir: '/mocked/root/dir' },
+}));
+
 describe('getSystemPrompt', () => {
   beforeEach(() => {
     vi.clearAllMocks();