genaicode 0.0.37 → 0.1.1

package/src/main/codegen.test.js

@@ -1,335 +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,
-  askQuestion: 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;
-}

package/src/prompt/function-defs/ask-question.js

@@ -1,33 +0,0 @@
-/**
- * Function definition for askQuestion
- */
-export const askQuestion = {
-  name: 'askQuestion',
-  description:
-    'If there is a need ask a question to the user to gather more information or clarification. Alternatively this function can be called also if there is no need to prompt the user with any question.',
-  parameters: {
-    type: 'object',
-    properties: {
-      content: {
-        type: 'string',
-        description:
-          'The message you want to display to the user, it can be either a question or a confirmation/ackoweledgment in case there is no intention to prompt the user.',
-      },
-      shouldPrompt: {
-        type: 'boolean',
-        description: 'Set to true if the intention is to get response from the user.',
-      },
-      promptNecessity: {
-        type: 'number',
-        minimum: 0,
-        maximum: 100,
-        description: 'How strong is the need to prompt the user? Higher value indicates a stronger need.',
-      },
-      stopCodegen: {
-        type: 'boolean',
-        description: 'If set to true, it will break the code generation process without error.',
-      },
-    },
-    required: ['content', 'shouldPrompt', 'promptNecessity', 'stopCodegen'],
-  },
-};

package/src/prompt/function-defs/codegen-summary.js

@@ -1,87 +0,0 @@
-import { temperature, cheap, vision } from '../../cli/cli-params.js';
-
-/**
- * Function definition for codegenSummary
- */
-export const codegenSummary = {
-  name: 'codegenSummary',
-  description:
-    'This function is called with a summary of proposed updates.' +
-    'Summary is a data structure(object) which contains:\n' +
-    '- `fileUpdates`: list of proposed file updates that will be subject to subsequent code generation request\n' +
-    '- `contextPaths`: list of file paths that make sense to use as a context for code generation requests.' +
-    '- `explanation`: general explanation of planned code generation updates\n' +
-    'It is crticially important to adhere to the schema of parameters',
-  parameters: {
-    type: 'object',
-    properties: {
-      contextPaths: {
-        type: 'array',
-        description:
-          'An array of absolute paths of files that should be used to provide context for the following updates. Context files could be for example the dependencies, or files that depend on one of the files that we want to update in the next step.',
-        items: {
-          type: 'string',
-        },
-      },
-      fileUpdates: {
-        type: 'array',
-        description: 'An array of proposed file updates, each update is an object with several properties.',
-        items: {
-          type: 'object',
-          description:
-            'Proposed update of a file. The update is an object which contains properties like file path, update tool name, and few other important properties.',
-          properties: {
-            path: { type: 'string', description: 'An absolute path of the project file that will be updated' },
-            updateToolName: {
-              type: 'string',
-              enum: [
-                'createFile',
-                'updateFile',
-                'patchFile',
-                'deleteFile',
-                'createDirectory',
-                'moveFile',
-                'generateImage',
-                'downloadFile',
-                'splitImage',
-                'resizeImage',
-                'imglyRemoveBackground',
-              ],
-              description: 'A name of the tool that will be used to perform the update.',
-            },
-            temperature: {
-              type: 'number',
-              description:
-                'Temperature parameter that will be used for LLM request. The value is adjusted to the characteristic of the update. If there is a need for a more creative solution, the value should be lower, but stil within [0.0, 2.0] range. The default value is: ' +
-                temperature,
-            },
-            cheap: {
-              type: 'boolean',
-              description:
-                'true value means that the prompt will be executed with cheaper model, which work faster, but provides lower quality results, so please use it only in situation when lower quality results are acceptable for the prompt. The default value is: ' +
-                !!cheap,
-            },
-            prompt: {
-              type: 'string',
-              description:
-                'Prompt that will be passed to the model request together with the tool request. It summarizes the planned changes for this particular file, so it should be detailed enough for the model to generate necessary changes.',
-            },
-            contextImageAssets: {
-              type: 'array',
-              description:
-                'A list of of absolute image asset paths that should be included to the context of LLM request.' +
-                'This parameter must be used if there is a need to analyze an image.',
-              items: { type: 'string' },
-            },
-          },
-          required: ['path', 'updateToolName', ...(vision ? ['contextImageAssets'] : [])],
-        },
-      },
-      explanation: {
-        type: 'string',
-        description: 'Explanation of planned changes or explanation of reasoning for no code changes',
-      },
-    },
-    required: ['fileUpdates', 'contextPaths'],
-  },
-};

package/src/prompt/function-defs/create-directory.js

@@ -1,21 +0,0 @@
-/**
- * Function definition for createDirectory
- */
-export const createDirectory = {
-  name: 'createDirectory',
-  description: 'Create a new directory',
-  parameters: {
-    type: 'object',
-    properties: {
-      filePath: {
-        type: 'string',
-        description: 'The directory path to create.',
-      },
-      explanation: {
-        type: 'string',
-        description: 'The explanation of the reasoning behind creating this directory',
-      },
-    },
-    required: ['filePath'],
-  },
-};

package/src/prompt/function-defs/create-file.js

@@ -1,26 +0,0 @@
-/**
- * Function definition for createFile
- */
-export const createFile = {
-  name: 'createFile',
-  description:
-    'Create a new file with specified content. The file will be created inside of project folder structure. This tool should not be used of creation if image files.',
-  parameters: {
-    type: 'object',
-    properties: {
-      filePath: {
-        type: 'string',
-        description: 'Path of the file that will be created, it must not be empty.',
-      },
-      newContent: {
-        type: 'string',
-        description: 'Content of the file that will be created, it must no be empty.',
-      },
-      explanation: {
-        type: 'string',
-        description: 'The explanation of the reasoning behind creating this file',
-      },
-    },
-    required: ['filePath', 'newContent'],
-  },
-};

package/src/prompt/function-defs/delete-file.js

@@ -1,21 +0,0 @@
-/**
- * Function definition for deleteFile
- */
-export const deleteFile = {
-  name: 'deleteFile',
-  description: 'Delete a specified file from the application source code.',
-  parameters: {
-    type: 'object',
-    properties: {
-      filePath: {
-        type: 'string',
-        description: 'The file path to delete.',
-      },
-      explanation: {
-        type: 'string',
-        description: 'The explanation of the reasoning behind deleting this file',
-      },
-    },
-    required: ['filePath'],
-  },
-};