genaicode 0.0.35 → 0.1.1

package/src/images/split-image.js

@@ -1,26 +0,0 @@
-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

@@ -1,120 +0,0 @@
-import assert from 'node:assert';
-import { exec } from 'child_process';
-import util from 'util';
-
-import {
-  dryRun,
-  chatGpt,
-  anthropic,
-  vertexAi,
-  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 '../main/config.js';
-import { getLintFixPrompt } from '../prompt/prompt-codegen.js';
-import { printHelpMessage } from '../cli/cli-options.js';
-
-const execPromise = util.promisify(exec);
-
-/** Executes codegen */
-export async function runCodegen() {
-  // Print to console the received parameters
-  console.log(`Received parameters: ${process.argv.slice(2).join(' ')}`);
-
-  validateCliParams();
-
-  // Handle --help option
-  if (helpRequested) {
-    printHelpMessage();
-    return;
-  }
-
-  if (rcConfig.lintCommand && !disableInitialLint) {
-    try {
-      console.log(`Executing lint command: ${rcConfig.lintCommand}`);
-      await execPromise(rcConfig.lintCommand);
-      console.log('Lint command executed successfully');
-    } catch (error) {
-      console.log(
-        'Lint command failed. Aborting codegen, please fix lint issues before running codegen, or use --disable-initial-lint',
-      );
-      console.log('Lint errors:', error.stdout, error.stderr);
-      process.exit(1);
-    }
-  } else if (rcConfig.lintCommand && disableInitialLint) {
-    console.log('Initial lint was skipped.');
-  }
-
-  const generateContent = vertexAiClaude
-    ? generateContentVertexAiClaude
-    : vertexAi
-      ? generateContentVertexAi
-      : anthropic
-        ? generateContentAnthropic
-        : chatGpt
-          ? 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, generateImage);
-  console.log('Received function calls:', functionCalls);
-
-  if (dryRun) {
-    console.log('Dry run mode, not updating files');
-  } else {
-    console.log('Update files');
-    await updateFiles(functionCalls.filter((call) => call.name !== 'explanation' && call.name !== 'getSourceCode'));
-    console.log('Initial updates applied');
-
-    // Check if lintCommand is specified in .genaicoderc
-    if (rcConfig.lintCommand) {
-      try {
-        console.log(`Executing lint command: ${rcConfig.lintCommand}`);
-        await execPromise(rcConfig.lintCommand);
-        console.log('Lint command executed successfully');
-      } catch (error) {
-        console.log('Lint command failed. Attempting to fix issues...');
-
-        // Prepare the lint error output for the second pass
-        const lintErrorPrompt = getLintFixPrompt(rcConfig.lintCommand, error.stdout, error.stderr);
-
-        console.log('Generating response for lint fixes');
-        const lintFixFunctionCalls = await promptService(generateContent, generateImage, lintErrorPrompt);
-
-        console.log('Received function calls for lint fixes:', lintFixFunctionCalls);
-
-        console.log('Applying lint fixes');
-        updateFiles(
-          lintFixFunctionCalls.filter((call) => call.name !== 'explanation' && call.name !== 'getSourceCode'),
-        );
-
-        // Run lint command again to verify fixes
-        try {
-          console.log(`Re-running lint command: ${rcConfig.lintCommand}`);
-          await execPromise(rcConfig.lintCommand);
-          console.log('Lint command executed successfully after fixes');
-        } catch (secondLintError) {
-          console.log('Lint command still failing after fixes. Manual intervention may be required.');
-          console.log('Lint errors:', secondLintError.stdout, secondLintError.stderr);
-        }
-      }
-    }
-
-    console.log('Done!');
-  }
-}

package/src/main/codegen.test.js

@@ -1,334 +0,0 @@
-/*eslint-disable no-import-assign*/
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { runCodegen } from './codegen.js';
-import * as vertexAi from '../ai-service/vertex-ai.js';
-import * as chatGpt from '../ai-service/chat-gpt.js';
-import * as anthropic from '../ai-service/anthropic.js';
-import * as vertexAiClaude from '../ai-service/vertex-ai-claude.js';
-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() }));
-vi.mock('../ai-service/anthropic.js', () => ({ generateContent: vi.fn() }));
-vi.mock('../ai-service/vertex-ai-claude.js', () => ({ generateContent: vi.fn() }));
-vi.mock('../files/update-files.js');
-vi.mock('../cli/cli-params.js', () => ({
-  requireExplanations: false,
-  considerAllFiles: false,
-  dependencyTree: false,
-  explicitPrompt: false,
-  allowFileCreate: false,
-  allowFileDelete: false,
-  allowDirectoryCreate: false,
-  allowFileMove: false,
-  verbosePrompt: false,
-  vertexAiClaude: false,
-  helpRequested: false,
-  vision: false,
-  imagen: false,
-  temperature: 0.7,
-  cheap: false,
-  taskFile: undefined,
-  disableInitialLint: undefined,
-}));
-vi.mock('../files/find-files.js', () => ({
-  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(() => {
-    vi.resetAllMocks();
-    cliParams.anthropic = false;
-    cliParams.chatGpt = false;
-    cliParams.vertexAi = false;
-    cliParams.vertexAiClaude = false;
-    cliParams.dryRun = false;
-    cliParams.helpRequested = false;
-    cliParams.vision = false;
-    cliParams.imagen = false;
-  });
-
-  it('should run codegen with Vertex AI by default', async () => {
-    cliParams.vertexAi = true;
-
-    const mockFunctionCalls = [
-      { name: 'updateFile', args: { filePath: 'test.js', newContent: 'console.log("Hello");' } },
-    ];
-    vertexAi.generateContent.mockResolvedValueOnce(mockFunctionCalls);
-
-    await runCodegen();
-
-    expect(vertexAi.generateContent).toHaveBeenCalled();
-    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
-  });
-
-  it('should run codegen with ChatGPT when chatGpt flag is true', async () => {
-    cliParams.chatGpt = true;
-
-    const mockFunctionCalls = [{ name: 'createFile', args: { filePath: 'new.js', newContent: 'const x = 5;' } }];
-    chatGpt.generateContent.mockResolvedValueOnce(mockFunctionCalls);
-
-    await runCodegen();
-
-    expect(chatGpt.generateContent).toHaveBeenCalled();
-    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
-  });
-
-  it('should run codegen with Anthropic when anthropic flag is true', async () => {
-    cliParams.anthropic = true;
-
-    const mockFunctionCalls = [{ name: 'deleteFile', args: { filePath: 'obsolete.js' } }];
-    anthropic.generateContent.mockResolvedValueOnce(mockFunctionCalls);
-
-    await runCodegen();
-
-    expect(anthropic.generateContent).toHaveBeenCalled();
-    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
-  });
-
-  it('should not update files in dry run mode', async () => {
-    cliParams.vertexAi = true;
-    cliParams.dryRun = true;
-
-    const mockFunctionCalls = [
-      { name: 'updateFile', args: { filePath: 'test.js', newContent: 'console.log("Dry run");' } },
-    ];
-    vertexAi.generateContent.mockResolvedValueOnce(mockFunctionCalls);
-
-    await runCodegen();
-
-    expect(vertexAi.generateContent).toHaveBeenCalled();
-    expect(updateFiles.updateFiles).not.toHaveBeenCalled();
-  });
-
-  it('should run codegen with Vertex AI Claude when vertexAiClaude flag is true', async () => {
-    cliParams.vertexAiClaude = true;
-
-    const mockFunctionCalls = [
-      { name: 'updateFile', args: { filePath: 'test.js', newContent: 'console.log("Hello from Claude");' } },
-    ];
-    vertexAiClaude.generateContent.mockResolvedValueOnce(mockFunctionCalls);
-
-    await runCodegen();
-
-    expect(vertexAiClaude.generateContent).toHaveBeenCalled();
-    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
-  });
-
-  it('should pass the temperature parameter to the AI service', async () => {
-    cliParams.vertexAi = true;
-    cliParams.temperature = 0.5;
-
-    const mockFunctionCalls = [
-      { name: 'updateFile', args: { filePath: 'test.js', newContent: 'console.log("Temperature test");' } },
-    ];
-    vertexAi.generateContent.mockResolvedValueOnce(mockFunctionCalls);
-
-    await runCodegen();
-
-    expect(vertexAi.generateContent).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      0.5,
-      false,
-    );
-    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
-  });
-
-  it('should print help message and not run codegen when --help option is provided', async () => {
-    cliParams.helpRequested = true;
-
-    await runCodegen();
-
-    expect(cliOptions.printHelpMessage).toHaveBeenCalled();
-    expect(vertexAi.generateContent).not.toHaveBeenCalled();
-    expect(chatGpt.generateContent).not.toHaveBeenCalled();
-    expect(anthropic.generateContent).not.toHaveBeenCalled();
-    expect(vertexAiClaude.generateContent).not.toHaveBeenCalled();
-    expect(updateFiles.updateFiles).not.toHaveBeenCalled();
-  });
-
-  it('should run codegen with vision when vision flag is true', async () => {
-    cliParams.chatGpt = true;
-    cliParams.vision = true;
-
-    const mockFunctionCalls = [
-      { name: 'updateFile', args: { filePath: 'test.js', newContent: 'console.log("Vision test");' } },
-    ];
-    chatGpt.generateContent.mockResolvedValueOnce(mockFunctionCalls);
-
-    await runCodegen();
-
-    expect(chatGpt.generateContent).toHaveBeenCalled();
-    expect(updateFiles.updateFiles).toHaveBeenCalledWith(mockFunctionCalls);
-    // Check if the generateContent function was called with the correct parameters
-    expect(chatGpt.generateContent.mock.calls[0][0]).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          type: 'user',
-          text: expect.stringContaining('I should also provide you with a summary of application image assets'),
-        }),
-        expect.objectContaining({
-          type: 'assistant',
-          text: expect.stringContaining('Please provide summary of application image assets.'),
-        }),
-        expect.objectContaining({
-          type: 'user',
-          functionResponses: [{ name: 'getImageAssets', content: expect.any(String) }],
-        }),
-      ]),
-    );
-  });
-
-  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: {
-          fileUpdates: [{ 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: {
-          fileUpdates: [{ 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: {
-          fileUpdates: [{ 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

@@ -1,33 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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/prompt/function-calling-validate.js

@@ -1,25 +0,0 @@
-import { Validator } from 'jsonschema';
-import { functionDefs } from './function-calling.js';
-
-export function validateFunctionCall(call) {
-  const validator = new Validator();
-  const functionDef = functionDefs.find((def) => def.name === call.name);
-
-  if (!functionDef) {
-    return {
-      errors: [
-        {
-          message: `Function "${call.name}" is not defined.`,
-        },
-      ],
-    };
-  }
-
-  const validationResult = validator.validate(call.args, functionDef.parameters);
-
-  if (validationResult.errors.length > 0) {
-    return validationResult;
-  }
-
-  return undefined;
-}