genaicode 0.0.35 → 0.1.1

package/src/ai-service/vertex-ai.js

@@ -1,156 +0,0 @@
-import assert from 'node:assert';
-import { VertexAI } from '@google-cloud/vertexai';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-import { geminiBlockNone } from '../cli/cli-params.js';
-
-/**
- * This function generates content using the Gemini Pro model.
- */
-
-export async function generateContent(prompt, functionDefs, requiredFunctionName, temperature, cheap = false) {
-  const messages = prompt
-    .filter((item) => item.type !== 'systemPrompt')
-    .map((item) => {
-      if (item.type === 'user') {
-        return {
-          role: 'user',
-          parts: [
-            ...(item.functionResponses ?? []).map((response) => ({
-              functionResponse: {
-                name: response.name,
-                response: { name: response.name, content: response.content },
-              },
-            })),
-            ...(item.images ?? []).map((image) => ({
-              inlineData: {
-                mimeType: image.mediaType,
-                data: image.base64url,
-              },
-            })),
-            { text: item.text },
-          ],
-        };
-      } else if (item.type === 'assistant') {
-        return {
-          role: 'model',
-          parts: [
-            ...(item.text ? [{ text: item.text }] : []),
-            ...item.functionCalls.map((call) => ({
-              functionCall: {
-                name: call.name,
-                args: call.args ?? {},
-              },
-            })),
-          ],
-        };
-      }
-    });
-
-  const req = {
-    contents: messages,
-    tools: [
-      {
-        functionDeclarations: functionDefs,
-      },
-    ],
-    toolConfig: {
-      functionCallingConfig: {
-        mode: cheap ? undefined : 'ANY',
-        ...(!cheap && requiredFunctionName ? { allowedFunctionNames: [requiredFunctionName] } : {}),
-      },
-    },
-  };
-
-  const model = await getGenModel(prompt.find((item) => item.type === 'systemPrompt').systemPrompt, temperature, cheap);
-
-  assert(await verifyVertexMonkeyPatch(), 'Vertex AI Tool Config was not monkey patched');
-
-  const result = await model.generateContent(req);
-
-  // Print token usage
-  const usageMetadata = result.response.usageMetadata;
-  const usage = {
-    inputTokens: usageMetadata.promptTokenCount,
-    outputTokens: usageMetadata.candidatesTokenCount,
-    totalTokens: usageMetadata.totalTokenCount,
-  };
-  printTokenUsageAndCost(usage, 0.000125 / 1000, 0.000375 / 1000);
-
-  if (result.response.promptFeedback) {
-    console.log('Prompt feedback:');
-    console.log(JSON.stringify(result.response.promptFeedback, null, 2));
-  }
-
-  if (!result.response.candidates?.length > 0) {
-    console.log('Response:', result);
-    throw new Error('No candidates found');
-  }
-
-  const functionCalls = result.response.candidates
-    .map((candidate) => candidate.content.parts?.map((part) => part.functionCall))
-    .flat()
-    .filter((functionCall) => !!functionCall);
-
-  if (functionCalls.length === 0) {
-    const textResponse = result.response.candidates
-      .map((candidate) => candidate.content.parts?.map((part) => part.text))
-      .flat()
-      .filter((text) => !!text)
-      .join('\n');
-    console.log('No function calls, output text response if it exists:', textResponse);
-  }
-
-  return processFunctionCalls(functionCalls);
-}
-
-// A function to get the generative model
-// Modified to accept temperature parameter and cheap flag
-export function getGenModel(systemPrompt, temperature, cheap = false) {
-  // Initialize Vertex with your Cloud project and location
-  const vertex_ai = new VertexAI({});
-  const model = cheap ? 'gemini-1.5-flash-001' : 'gemini-1.5-pro-001';
-
-  console.log(`Using Vertex AI model: ${model}`);
-
-  // Instantiate the models
-  return vertex_ai.preview.getGenerativeModel({
-    model: model,
-    generationConfig: {
-      maxOutputTokens: 8192,
-      temperature: temperature,
-      topP: 0.95,
-    },
-    safetySettings: [
-      {
-        category: 'HARM_CATEGORY_HATE_SPEECH',
-        threshold: geminiBlockNone ? 'BLOCK_NONE' : 'BLOCK_LOW_AND_ABOVE',
-      },
-      {
-        category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
-        threshold: geminiBlockNone ? 'BLOCK_NONE' : 'BLOCK_LOW_AND_ABOVE',
-      },
-      {
-        category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
-        threshold: geminiBlockNone ? 'BLOCK_NONE' : 'BLOCK_LOW_AND_ABOVE',
-      },
-      {
-        category: 'HARM_CATEGORY_HARASSMENT',
-        threshold: geminiBlockNone ? 'BLOCK_NONE' : 'BLOCK_LOW_AND_ABOVE',
-      },
-    ],
-    systemInstruction: {
-      role: 'system',
-      parts: [
-        {
-          text: systemPrompt,
-        },
-      ],
-    },
-  });
-}
-
-export async function verifyVertexMonkeyPatch() {
-  return (await import('@google-cloud/vertexai/build/src/functions/generate_content.js')).generateContent
-    .toString()
-    .includes('// MONKEY PATCH TOOL_CONFIG');
-}

package/src/cli/cli-options.js

@@ -1,120 +0,0 @@
-// CLI options and their descriptions
-const cliOptions = [
-  {
-    name: '--help',
-    description: 'Display this help message.',
-  },
-  {
-    name: '--dry-run',
-    description: 'Run the codegen script without updating the source code.',
-  },
-  {
-    name: '--consider-all-files',
-    description: "Consider all files for code generation, even if they don't contain the @" + 'CODEGEN comments.',
-  },
-  {
-    name: '--allow-file-create',
-    description: 'Allow the codegen script to create new files.',
-  },
-  {
-    name: '--allow-file-delete',
-    description: 'Allow the codegen script to delete files.',
-  },
-  {
-    name: '--allow-directory-create',
-    description: 'Allow codegen script to create directories.',
-  },
-  {
-    name: '--allow-file-move',
-    description: 'Allow the codegen script to move files.',
-  },
-  {
-    name: '--chat-gpt',
-    description: "Use the OpenAI model for code generation instead of Vertex AI with Google's Gemini Pro model.",
-  },
-  {
-    name: '--anthropic',
-    description: "Use Anthropic's Claude model for code generation.",
-  },
-  {
-    name: '--vertex-ai',
-    description:
-      "Use Vertex AI with Google's Gemini Pro model for code generation (default if no AI model is specified).",
-  },
-  {
-    name: '--vertex-ai-claude',
-    description: 'Use Claude via Vertex AI for code generation.',
-  },
-  {
-    name: '--explicit-prompt=<prompt>',
-    description: 'An explicit prompt to use for code generation.',
-  },
-  {
-    name: '--task-file=<file>',
-    description: 'Specifies a file with a task description for code generation.',
-  },
-  {
-    name: '--dependency-tree',
-    description: 'Limit the scope of codegen only to files marked with @' + 'CODEGEN and their dependencies.',
-  },
-  {
-    name: '--verbose-prompt',
-    description: 'Print the prompt used for code generation.',
-  },
-  {
-    name: '--require-explanations',
-    description: 'Require explanations for all code generation operations.',
-  },
-  {
-    name: '--disable-context-optimization',
-    description: 'Disable the optimization that uses context paths for more efficient code generation.',
-  },
-  {
-    name: '--gemini-block-none',
-    description: 'Disable safety settings for Gemini Pro model (requires whitelisted Cloud project).',
-  },
-  {
-    name: '--disable-initial-lint',
-    description: 'Skip the initial lint check before running the code generation process.',
-  },
-  {
-    name: '--temperature=<value>',
-    description: 'Set the temperature parameter for the AI model (default: 0.7).',
-  },
-  {
-    name: '--vision',
-    description:
-      'Enable vision capabilities for processing image inputs. This option allows the tool to analyze and generate code based on image content when used with compatible AI models.',
-  },
-  {
-    name: '--imagen=<service>',
-    description:
-      'Enable image generation functionality and specify the service to use (either "vertex-ai" or "dall-e").',
-  },
-  {
-    name: '--cheap',
-    description: 'Switch to cheaper models in AI services for content and image generation.',
-  },
-  {
-    name: '--content-mask=<path>',
-    description:
-      'Apply a content mask to limit the initial source code files included in the request. The value should be a prefix of the path relative to rootDir.',
-  },
-];
-
-/**
- * Print the help message with all available CLI options
- */
-export function printHelpMessage() {
-  console.log('GenAIcode - AI-powered code generation tool');
-  console.log('\nUsage: npx genaicode [options]');
-  console.log('\nOptions:');
-
-  cliOptions.forEach((option) => {
-    console.log(`  ${option.name.padEnd(30)} ${option.description}`);
-  });
-
-  console.log('\nFor more information, please refer to the project home page: https://github.com/gtanczyk/genaicode/');
-}
-
-export { cliOptions };

package/src/cli/cli-options.test.js

@@ -1,50 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { printHelpMessage, cliOptions } from './cli-options.js';
-
-describe('CLI Options', () => {
-  describe('printHelpMessage', () => {
-    it('should print the help message with all CLI options', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      printHelpMessage();
-
-      expect(consoleSpy).toHaveBeenCalledWith('GenAIcode - AI-powered code generation tool');
-      expect(consoleSpy).toHaveBeenCalledWith('\nUsage: npx genaicode [options]');
-      expect(consoleSpy).toHaveBeenCalledWith('\nOptions:');
-
-      cliOptions.forEach((option) => {
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining(option.name));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining(option.description));
-      });
-
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('For more information'));
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should include the --imagen option in the help message', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      printHelpMessage();
-
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('--imagen=<service>'));
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining(
-          'Enable image generation functionality and specify the service to use (either "vertex-ai" or "dall-e").',
-        ),
-      );
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('cliOptions', () => {
-    it('should include the --imagen option', () => {
-      const imagenOption = cliOptions.find((option) => option.name === '--imagen=<service>');
-      expect(imagenOption).toBeDefined();
-      expect(imagenOption.description).toBe(
-        'Enable image generation functionality and specify the service to use (either "vertex-ai" or "dall-e").',
-      );
-    });
-  });
-});

package/src/cli/cli-params.js

@@ -1,99 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { serviceAutoDetect } from './service-autodetect.js';
-import { rcConfig } from '../main/config.js';
-
-const params = process.argv.slice(2);
-
-export const dryRun = params.includes('--dry-run');
-export const considerAllFiles = params.includes('--consider-all-files');
-export const allowFileCreate = params.includes('--allow-file-create');
-export const allowFileDelete = params.includes('--allow-file-delete');
-export const allowDirectoryCreate = params.includes('--allow-directory-create');
-export const allowFileMove = params.includes('--allow-file-move');
-export let chatGpt = params.includes('--chat-gpt');
-export let anthropic = params.includes('--anthropic');
-export let vertexAi = params.includes('--vertex-ai');
-export let vertexAiClaude = params.includes('--vertex-ai-claude');
-export const dependencyTree = params.includes('--dependency-tree');
-export const verbosePrompt = params.includes('--verbose-prompt');
-export let explicitPrompt = params.find((param) => param.startsWith('--explicit-prompt'))?.split('=')[1];
-export const disableContextOptimization = params.includes('--disable-context-optimization');
-export let taskFile = params.find((param) => param.startsWith('--task-file'))?.split('=')[1];
-export const requireExplanations = params.includes('--require-explanations');
-export const geminiBlockNone = params.includes('--gemini-block-none');
-export const disableInitialLint = params.includes('--disable-initial-lint');
-export const vision = params.includes('--vision');
-export const imagen = params.find((param) => param.startsWith('--imagen'))?.split('=')[1];
-export const cheap = params.includes('--cheap');
-
-// Add support for --help option
-export const helpRequested = params.includes('--help');
-
-// Export the lintCommand from rcConfig
-export const lintCommand = rcConfig.lintCommand || null;
-
-// Temperature parameter
-export const temperature = parseFloat(
-  params.find((param) => param.startsWith('--temperature='))?.split('=')[1] || '0.7',
-); // Default temperature value: 0.7
-
-// New content mask parameter
-export const contentMask = params.find((param) => param.startsWith('--content-mask='))?.split('=')[1] || null;
-
-if (taskFile) {
-  if (explicitPrompt) {
-    throw new Error('The --task-file option is exclusive with the --explicit-prompt option');
-  }
-  if (!fs.existsSync(taskFile)) {
-    throw new Error(`The task file ${taskFile} does not exist`);
-  }
-  if (!path.isAbsolute(taskFile)) {
-    taskFile = path.join(process.cwd(), taskFile);
-  }
-  explicitPrompt = `I want you to perform a coding task. The task is described in the ${taskFile} file. Use those instructions.`;
-}
-
-if (considerAllFiles && dependencyTree) {
-  throw new Error('--consider-all-files and --dependency-tree are exclusive.');
-}
-
-if ([chatGpt, anthropic, vertexAi, vertexAiClaude].filter(Boolean).length > 1) {
-  throw new Error('--chat-gpt, --anthropic, --vertex-ai, and --vertex-ai-claude are mutually exclusive.');
-}
-
-if (!chatGpt && !anthropic && !vertexAi && !vertexAiClaude && !helpRequested) {
-  const detected = serviceAutoDetect();
-  if (detected === 'anthropic') {
-    console.log('Autodetected --anthropic');
-    anthropic = true;
-  } else if (detected === 'chat-gpt') {
-    console.log('Autodetected --chat-gpt');
-    chatGpt = true;
-  } else if (detected === 'vertex-ai') {
-    console.log('Autodetected --vertex-ai');
-    vertexAi = true;
-  } else {
-    throw new Error('Missing --chat-gpt, --anthropic, --vertex-ai, or --vertex-ai-claude');
-  }
-}
-
-if (lintCommand) {
-  console.log(`Lint command detected: ${lintCommand}`);
-}
-
-if (temperature) {
-  console.log(`Temperature value: ${temperature}`);
-}
-
-if (imagen) {
-  console.log('Image generation functionality enabled');
-}
-
-if (cheap) {
-  console.log('Cheaper AI models will be used for content and image generation');
-}
-
-if (contentMask) {
-  console.log(`Content mask: ${contentMask}`);
-}

package/src/cli/cli-params.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { serviceAutoDetect } from './service-autodetect';
-
-describe('serviceAutoDetect', () => {
-  afterEach(() => {
-    // Clean up environment variables after each test
-    delete process.env.ANTHROPIC_API_KEY;
-    delete process.env.OPENAI_API_KEY;
-    delete process.env.GOOGLE_CLOUD_PROJECT;
-  });
-
-  it('should return "anthropic" when ANTHROPIC_API_KEY is set', () => {
-    process.env.ANTHROPIC_API_KEY = 'test-key';
-    expect(serviceAutoDetect()).toBe('anthropic');
-  });
-
-  it('should return "chat-gpt" when OPENAI_API_KEY is set', () => {
-    process.env.OPENAI_API_KEY = 'test-key';
-    expect(serviceAutoDetect()).toBe('chat-gpt');
-  });
-
-  it('should return "vertex-ai" when GOOGLE_CLOUD_PROJECT is set', () => {
-    process.env.GOOGLE_CLOUD_PROJECT = 'test-project';
-    expect(serviceAutoDetect()).toBe('vertex-ai');
-  });
-
-  it('should return null when no service is configured', () => {
-    expect(serviceAutoDetect()).toBeNull();
-  });
-
-  it('should prioritize anthropic over other services', () => {
-    process.env.ANTHROPIC_API_KEY = 'test-key';
-    process.env.OPENAI_API_KEY = 'test-key';
-    process.env.GOOGLE_CLOUD_PROJECT = 'test-project';
-    expect(serviceAutoDetect()).toBe('anthropic');
-  });
-
-  it('should prioritize chat-gpt over vertex-ai', () => {
-    process.env.OPENAI_API_KEY = 'test-key';
-    process.env.GOOGLE_CLOUD_PROJECT = 'test-project';
-    expect(serviceAutoDetect()).toBe('chat-gpt');
-  });
-});

package/src/cli/service-autodetect.js

@@ -1,11 +0,0 @@
-/** Detects if one of ai services is configured */
-export function serviceAutoDetect() {
-  if (process.env.ANTHROPIC_API_KEY) {
-    return 'anthropic';
-  } else if (process.env.OPENAI_API_KEY) {
-    return 'chat-gpt';
-  } else if (process.env.GOOGLE_CLOUD_PROJECT) {
-    return 'vertex-ai';
-  }
-  return null;
-}

package/src/cli/service-autodetect.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { serviceAutoDetect } from './service-autodetect';
-
-describe('serviceAutoDetect', () => {
-  afterEach(() => {
-    // Clean up environment variables after each test
-    delete process.env.ANTHROPIC_API_KEY;
-    delete process.env.OPENAI_API_KEY;
-    delete process.env.GOOGLE_CLOUD_PROJECT;
-  });
-
-  it('should return "anthropic" when ANTHROPIC_API_KEY is set', () => {
-    process.env.ANTHROPIC_API_KEY = 'test-key';
-    expect(serviceAutoDetect()).toBe('anthropic');
-  });
-
-  it('should return "chat-gpt" when OPENAI_API_KEY is set', () => {
-    process.env.OPENAI_API_KEY = 'test-key';
-    expect(serviceAutoDetect()).toBe('chat-gpt');
-  });
-
-  it('should return "vertex-ai" when GOOGLE_CLOUD_PROJECT is set', () => {
-    process.env.GOOGLE_CLOUD_PROJECT = 'test-project';
-    expect(serviceAutoDetect()).toBe('vertex-ai');
-  });
-
-  it('should return null when no service is configured', () => {
-    expect(serviceAutoDetect()).toBeNull();
-  });
-
-  it('should prioritize anthropic over other services', () => {
-    process.env.ANTHROPIC_API_KEY = 'test-key';
-    process.env.OPENAI_API_KEY = 'test-key';
-    process.env.GOOGLE_CLOUD_PROJECT = 'test-project';
-    expect(serviceAutoDetect()).toBe('anthropic');
-  });
-
-  it('should prioritize chat-gpt over vertex-ai', () => {
-    process.env.OPENAI_API_KEY = 'test-key';
-    process.env.GOOGLE_CLOUD_PROJECT = 'test-project';
-    expect(serviceAutoDetect()).toBe('chat-gpt');
-  });
-});

package/src/cli/validate-cli-params.js

@@ -1,117 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { rcConfig } from '../main/config.js';
-
-// List of allowed CLI parameters
-const allowedParameters = [
-  '--dry-run',
-  '--consider-all-files',
-  '--allow-file-create',
-  '--allow-file-delete',
-  '--allow-directory-create',
-  '--allow-file-move',
-  '--chat-gpt',
-  '--vertex-ai',
-  '--vertex-ai-claude',
-  '--anthropic',
-  '--explicit-prompt=',
-  '--task-file=',
-  '--dependency-tree',
-  '--verbose-prompt',
-  '--require-explanations',
-  '--disable-context-optimization',
-  '--gemini-block-none',
-  '--disable-initial-lint',
-  '--temperature=',
-  '--vision',
-  '--imagen=',
-  '--cheap',
-  '--help',
-  '--content-mask=',
-];
-
-/**
- * Validate CLI parameters according to those mentioned in README.md
- * Fail the process if not valid, or if an unknown parameter is passed
- * @throws {Error} If an invalid parameter is provided
- */
-export function validateCliParams() {
-  const providedParameters = process.argv.slice(2);
-
-  // Check if --help is present
-  const helpRequested = providedParameters.includes('--help');
-
-  if (helpRequested) {
-    // If --help is present, no other parameters should be allowed
-    if (providedParameters.length > 1) {
-      console.error('The --help option cannot be used with other parameters.');
-      process.exit(1);
-    }
-    return; // Exit the function early as no further validation is needed
-  }
-
-  providedParameters.forEach((param) => {
-    if (!param.startsWith('--')) {
-      console.error(`Invalid parameter: ${param}, all parameters must start with --`);
-      process.exit(1);
-    }
-    if (!allowedParameters.some((p) => (p.endsWith('=') && param.startsWith(p)) || param === p)) {
-      console.error(`Invalid parameter: ${param}, allowed parameters are: ${allowedParameters.join(', ')}`);
-      process.exit(1);
-    }
-  });
-
-  // Validate temperature parameter, it must be a number between 0.0 and 2.0
-  const temperatureParam = providedParameters.find((param) => param.startsWith('--temperature='));
-  if (temperatureParam) {
-    const temperatureValue = parseFloat(temperatureParam.split('=')[1]);
-    if (isNaN(temperatureValue) || temperatureValue < 0.0 || temperatureValue > 2.0) {
-      console.error('Invalid temperature value. It must be a number between 0.0 and 2.0.');
-      process.exit(1);
-    }
-  }
-
-  // Validate --imagen parameter
-  const imagenParam = providedParameters.find((param) => param.startsWith('--imagen='));
-  if (imagenParam) {
-    const imagenValue = imagenParam.split('=')[1];
-    if (imagenValue !== 'vertex-ai' && imagenValue !== 'dall-e') {
-      throw new Error('Invalid --imagen value. It must be either "vertex-ai" or "dall-e".');
-    }
-  }
-
-  if (providedParameters.includes('--vision') && providedParameters.includes('--vertex-ai')) {
-    throw new Error('--vision and --vertex-ai are currently not supported together.');
-  }
-
-  // Validate content mask parameter
-  const contentMaskParam = providedParameters.find((param) => param.startsWith('--content-mask='));
-  if (contentMaskParam) {
-    const contentMaskValue = contentMaskParam.split('=')[1];
-    const fullPath = path.join(rcConfig.rootDir, contentMaskValue);
-    if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
-      throw new Error(
-        `Invalid --content-mask value. The path "${contentMaskValue}" does not exist or is not a directory within the project.`,
-      );
-    }
-  }
-}
-
-/**
- * Get the value of a CLI parameter
- * @param {string} paramName - The name of the parameter to get the value for
- * @returns {string|null} The value of the parameter, or null if not found
- */
-export function getCliParamValue(paramName) {
-  const param = process.argv.find((arg) => arg.startsWith(`${paramName}=`));
-  return param ? param.split('=')[1] : null;
-}
-
-/**
- * Check if a CLI parameter is present
- * @param {string} paramName - The name of the parameter to check
- * @returns {boolean} True if the parameter is present, false otherwise
- */
-export function hasCliParam(paramName) {
-  return process.argv.includes(paramName) || !!getCliParamValue(paramName);
-}