genaicode 0.0.31

package/src/files/update-files.js

@@ -0,0 +1,118 @@
+import fs from 'fs';
+import path from 'path';
+import assert from 'node:assert';
+import * as diff from 'diff';
+
+import { isAncestorDirectory, getSourceFiles, rootDir } from './find-files.js';
+import {
+  allowDirectoryCreate,
+  allowFileCreate,
+  allowFileDelete,
+  allowFileMove,
+  anthropic,
+  chatGpt,
+  vertexAiClaude,
+} from '../cli/cli-params.js';
+
+/**
+ * @param functionCalls Result of the code generation, a map of file paths to new content
+ */
+export async function updateFiles(functionCalls) {
+  for (const { name, args } of functionCalls) {
+    let { filePath, newContent, source, destination, patch } = args;
+
+    // Check if filePath is absolute, if not use rootDir as baseline
+    if (name !== 'moveFile') {
+      filePath = path.isAbsolute(filePath) ? filePath : path.join(rootDir, filePath);
+    } else {
+      source = path.isAbsolute(source) ? source : path.join(rootDir, source);
+      destination = path.isAbsolute(destination) ? destination : path.join(rootDir, destination);
+    }
+
+    // ignore files which are not located inside project directory (sourceFiles)
+    if (
+      (name !== 'moveFile' && !isProjectPath(filePath)) ||
+      (name === 'moveFile' && (!isProjectPath(source) || !isProjectPath(destination)))
+    ) {
+      console.log(`Skipping file: ${filePath || source}`);
+      throw new Error(`File ${filePath || source} is not located inside project directory, something is wrong?`);
+    }
+
+    if (name === 'deleteFile') {
+      assert(allowFileDelete, 'File delete option was not enabled');
+      console.log(`Removing file: ${filePath}`);
+      fs.unlinkSync(filePath);
+    } else if (name === 'createDirectory') {
+      assert(allowDirectoryCreate, 'Directory create option was not enabled');
+      console.log(`Creating directory: ${filePath}`);
+      fs.mkdirSync(filePath, { recursive: true });
+    } else if (name === 'updateFile' || name === 'createFile' || name === 'patchFile') {
+      if (name === 'patchFile') {
+        console.log(`Applying a patch: ${filePath} content`);
+        newContent = diff.applyPatch(fs.readFileSync(filePath, 'utf-8'), patch);
+        assert(!!newContent, 'Patch was not successful');
+      }
+
+      assert(!!newContent, 'newContent must not be empty');
+      if (name === 'createFile') {
+        console.log(`Creating file: ${filePath}`);
+        assert(allowFileCreate, 'File create option was not enabled');
+        assert(!fs.existsSync(filePath), 'File already exists');
+        if (allowDirectoryCreate) {
+          fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        }
+      } else {
+        console.log(`Updating file: ${filePath}`);
+        assert(fs.existsSync(filePath), 'File does not exist');
+      }
+      fs.writeFileSync(
+        filePath,
+        chatGpt || anthropic || vertexAiClaude
+          ? newContent
+          : // Fixing a problem caused by vertex function calling. Possibly not a good fix
+            newContent.replace(/\\n/g, '\n').replace(/\\'/g, "'"),
+        'utf-8',
+      );
+    } else if (name === 'moveFile') {
+      console.log(`Moving file from ${source} to ${destination}`);
+      assert(fs.existsSync(source), 'Source file does not exist');
+      assert(!fs.existsSync(destination), 'Destination file already exists');
+      assert(allowFileMove, 'File move option was not enabled');
+      if (allowDirectoryCreate) {
+        fs.mkdirSync(path.dirname(destination), { recursive: true });
+      }
+      fs.renameSync(source, destination);
+    } else if (name === 'downloadFile') {
+      console.log(`Downloading image: ${filePath}`);
+      assert(fs.existsSync(filePath) || allowFileCreate, 'File create option was not enabled and file does not exist');
+      if (allowDirectoryCreate) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      }
+      try {
+        assert(args.downloadUrl, 'image url is not empty');
+        const imageResponse = await fetch(args.downloadUrl);
+        const arrayBuffer = await imageResponse.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        fs.writeFileSync(filePath, buffer);
+        console.log(`Image download and saved to: ${filePath}`);
+      } catch (error) {
+        console.error(`Failed to download image: ${error.message}`);
+        throw error;
+      }
+    }
+  }
+}
+
+function isProjectPath(filePath) {
+  const sourceFiles = getSourceFiles();
+
+  return (
+    isAncestorDirectory(rootDir, filePath) ||
+    sourceFiles.includes(filePath) ||
+    !sourceFiles.some(
+      (sourceFile) =>
+        path.dirname(filePath) === path.dirname(sourceFile) ||
+        isAncestorDirectory(path.dirname(sourceFile), path.dirname(filePath)),
+    )
+  );
+}

package/src/main/codegen.js

@@ -0,0 +1,113 @@
+import assert from 'node:assert';
+import { exec } from 'child_process';
+import util from 'util';
+
+import {
+  dryRun,
+  chatGpt,
+  anthropic,
+  vertexAi,
+  vertexAiClaude,
+  disableInitialLint,
+  helpRequested,
+} 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 { promptService } from '../prompt/prompt-service.js';
+import { updateFiles } from '../files/update-files.js';
+import { rcConfig } from '../files/find-files.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');
+
+  console.log('Generating response');
+  let functionCalls = await promptService(generateContent);
+  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, 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

@@ -0,0 +1,186 @@
+/*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';
+
+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,
+}));
+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(),
+}));
+
+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;
+  });
+
+  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);
+    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) }],
+        }),
+      ]),
+    );
+  });
+});

package/src/prompt/limits.js

@@ -0,0 +1,23 @@
+import assert from 'node:assert';
+
+const SYSTEM_PROMPT_LIMIT = 200;
+const CODEGEN_PROMPT_LIMIT = 500;
+const SOURCE_CODE_LIMIT = 20000;
+
+function verifyPromptLimit(promptType, prompt, limit) {
+  const tokenCount = prompt.split(/\s+/).length;
+  console.log(`${promptType} prompt token count: ${tokenCount}`);
+  assert(tokenCount <= limit, `Token limit exceeded: ${tokenCount} > ${limit}`);
+}
+
+export function verifySystemPromptLimit(systemPrompt) {
+  verifyPromptLimit('system', systemPrompt, SYSTEM_PROMPT_LIMIT);
+}
+
+export function verifyCodegenPromptLimit(codeGenPrompt) {
+  verifyPromptLimit('codegen', codeGenPrompt, CODEGEN_PROMPT_LIMIT);
+}
+
+export function verifySourceCodeLimit(sourceCode) {
+  verifyPromptLimit('sourceCode', sourceCode, SOURCE_CODE_LIMIT);
+}

package/src/prompt/limits.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { verifySystemPromptLimit, verifyCodegenPromptLimit, verifySourceCodeLimit } from './limits.js';
+
+describe('Prompt Limits', () => {
+  describe('verifySystemPromptLimit', () => {
+    it('should not throw for a prompt within the limit', () => {
+      const validPrompt = 'A '.repeat(200 - 1);
+      expect(() => verifySystemPromptLimit(validPrompt)).not.toThrow();
+    });
+
+    it('should throw for a prompt exceeding the limit', () => {
+      const invalidPrompt = 'A '.repeat(201);
+      expect(() => verifySystemPromptLimit(invalidPrompt)).toThrow('Token limit exceeded: 202 > 200');
+    });
+  });
+
+  describe('verifyCodegenPromptLimit', () => {
+    it('should not throw for a prompt within the limit', () => {
+      const validPrompt = 'B '.repeat(200 - 1);
+      expect(() => verifyCodegenPromptLimit(validPrompt)).not.toThrow();
+    });
+
+    it('should throw for a prompt exceeding the limit', () => {
+      const invalidPrompt = 'B '.repeat(501);
+      expect(() => verifyCodegenPromptLimit(invalidPrompt)).toThrow('Token limit exceeded: 502 > 500');
+    });
+  });
+
+  describe('verifySourceCodeLimit', () => {
+    it('should not throw for source code within the limit', () => {
+      const validSourceCode = 'C '.repeat(20000 - 1);
+      expect(() => verifySourceCodeLimit(validSourceCode)).not.toThrow();
+    });
+
+    it('should throw for source code exceeding the limit', () => {
+      const invalidSourceCode = 'C '.repeat(20001);
+      expect(() => verifySourceCodeLimit(invalidSourceCode)).toThrow('Token limit exceeded: 20002 > 20000');
+    });
+  });
+});

package/src/prompt/prompt-codegen.js

@@ -0,0 +1,106 @@
+import assert from 'node:assert';
+import { getSourceCode } from '../files/read-files.js';
+import { CODEGEN_TRIGGER } from './prompt-consts.js';
+import {
+  considerAllFiles,
+  allowFileCreate,
+  allowFileDelete,
+  allowDirectoryCreate,
+  allowFileMove,
+  explicitPrompt,
+  dependencyTree,
+  verbosePrompt,
+  vision,
+  imagen,
+} from '../cli/cli-params.js';
+import { getDependencyList } from '../files/find-files.js';
+import { verifyCodegenPromptLimit } from './limits.js';
+
+/** Get codegen prompt */
+export function getCodeGenPrompt() {
+  let codeGenFiles;
+  if (considerAllFiles) {
+    codeGenFiles = Object.keys(getSourceCode());
+  } else {
+    codeGenFiles = Object.entries(getSourceCode())
+      .filter(([, content]) => content.match(new RegExp("([^'^`]+)" + CODEGEN_TRIGGER)))
+      .map(([path]) => path);
+  }
+
+  // Add logic to consider dependency tree
+  if (dependencyTree) {
+    assert(codeGenFiles.length > 0, `You must use ${CODEGEN_TRIGGER} together with --dependency-tree`);
+
+    const dependencyTreeFiles = new Set();
+    codeGenFiles
+      .map(getDependencyList)
+      .flat()
+      .forEach((key) => dependencyTreeFiles.add(key));
+    codeGenFiles = Array.from(dependencyTreeFiles);
+  }
+
+  const codeGenPrompt =
+    (explicitPrompt ? explicitPrompt + '\n\n' : '') +
+    `${
+      considerAllFiles
+        ? codeGenFiles.length > 0
+          ? `I have marked some files with the ${CODEGEN_TRIGGER} fragments:\n${codeGenFiles.join('\n')}`
+          : `No files are marked with ${CODEGEN_TRIGGER} fragment, so you can consider doing changes in any file.`
+        : `Generate updates only for the following files:\n${codeGenFiles.join('\n')}`
+    }
+
+${
+  considerAllFiles
+    ? 'You are allowed to modify all files in the application regardless if they contain codegen fragments or not.'
+    : 'Do not modify files which do not contain the fragments.'
+}
+${allowFileCreate ? 'You are allowed to create new files.' : 'Do not create new files.'}
+${
+  allowFileDelete
+    ? 'You are allowed to delete files, in such case add empty string as content.'
+    : 'Do not delete files.'
+}
+${allowDirectoryCreate ? 'You are allowed to create new directories.' : 'Do not create new directories.'}
+${allowFileMove ? 'You are allowed to move files.' : 'Do not move files.'}
+${vision ? 'You are allowed to analyze image assets.' : 'Do not analyze image assets.'}
+${imagen ? 'You are allowed to generate images.' : 'You are not allowed to generate images.'}
+`;
+
+  if (verbosePrompt) {
+    console.log('Code gen prompt:');
+    console.log(codeGenPrompt);
+  }
+
+  verifyCodegenPromptLimit(codeGenPrompt);
+
+  return codeGenPrompt;
+}
+
+/** Get lint fix prompt */
+export function getLintFixPrompt(command, stdout, stderr) {
+  const lintFixPrompt = `The following lint errors were encountered after the initial code generation:
+
+Lint command: ${command}
+Lint command stdout:
+
+\`\`\`
+${stdout}
+\`\`\`
+
+Lint command stderr:
+
+\`\`\`
+${stderr}
+\`\`\`
+        
+Please suggest changes to fix these lint errors.`;
+
+  if (verbosePrompt) {
+    console.log('Lint fix prompt:');
+    console.log(lintFixPrompt);
+  }
+
+  verifyCodegenPromptLimit(lintFixPrompt);
+
+  return lintFixPrompt;
+}