genaicode 0.0.37 → 0.1.1

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

@@ -1,78 +0,0 @@
-import fs from 'fs';
-import mime from 'mime-types';
-import { PredictionServiceClient, helpers } from '@google-cloud/aiplatform';
-import { setTempBuffer } from '../files/temp-buffer.js';
-import { resizeImageBuffer } from '../images/resize-image.js';
-
-/**
- * Generate an image using Vertex AI's Imagen model and return the image URL
- * @param {string} prompt - The description of the image to generate
- * @param {string|undefined} contextImagePath - The image to be used as a context
- * @param {{width: number, height: number}} size - The size of the image to generate
- * @param {boolean} cheap - Whether to use a cheaper model
- * @returns {Promise<string>} - The url of the generated image
- */
-export async function generateImage(prompt, contextImagePath, size, cheap = false) {
-  // Initialize the PredictionServiceClient
-  const client = new PredictionServiceClient({
-    apiEndpoint: `${process.env.GOOGLE_CLOUD_REGION}-aiplatform.googleapis.com`,
-  });
-
-  // Set the project and location
-  const projectId = process.env.GOOGLE_CLOUD_PROJECT;
-  const location = process.env.GOOGLE_CLOUD_REGION;
-
-  // Set the model name based on the cheap parameter
-  const modelName = contextImagePath
-    ? 'imagegeneration@002'
-    : cheap
-      ? 'imagen-3.0-fast-generate-001'
-      : 'imagen-3.0-generate-001';
-  console.log(`Using Vertex AI Imagen model: ${modelName}`);
-
-  try {
-    // Prepare the request
-    const request = {
-      endpoint: `projects/${projectId}/locations/${location}/publishers/google/models/${modelName}`,
-      instances: [
-        helpers.toValue({
-          prompt: prompt,
-          ...(contextImagePath
-            ? {
-                image: {
-                  bytesBase64Encoded: fs.readFileSync(contextImagePath, 'base64'),
-                  mediaType: mime.lookup(contextImagePath),
-                },
-              }
-            : {}),
-        }),
-      ],
-      parameters: helpers.toValue({
-        sampleCount: 1,
-        safetySetting: 'block_most',
-        personGeneration: 'allow_adult',
-        includeRaiReason: true,
-        language: 'auto',
-        aspectRatio: '1:1',
-        addWatermark: false,
-      }),
-    };
-
-    // Make the prediction request
-    const [response] = await client.predict(request);
-
-    if (response.predictions && response.predictions.length > 0) {
-      const prediction = helpers.fromValue(response.predictions[0]);
-      if (prediction.bytesBase64Encoded) {
-        console.log(`Image generated successfully, resizing to desired dimension`, size);
-        const buffer = Buffer.from(prediction.bytesBase64Encoded, 'base64');
-        return setTempBuffer(await resizeImageBuffer(buffer, size));
-      }
-    }
-
-    throw new Error('No image generated in the response');
-  } catch (error) {
-    console.error('Error generating image:', error);
-    throw error;
-  }
-}

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,132 +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.',
-  },
-  {
-    name: '--ignore-pattern=<pattern>',
-    description: 'Specify a pattern of files to ignore during the initial source code fetching.',
-  },
-  {
-    name: '--disable-cache',
-    description: 'Disable caching for the application.',
-  },
-  {
-    name: '--ask-question',
-    description: 'Allows the AI assistant to ask questions for clarification during the code generation process.',
-  },
-];
-
-/**
- * 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,114 +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 const disableCache = params.includes('--disable-cache');
-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');
-export const askQuestion = params.includes('--ask-question');
-
-// 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;
-
-// New ignore pattern parameter
-export const ignorePatterns = params
-  .filter((param) => param.startsWith('--ignore-pattern='))
-  .map((param) => param.split('=')[1]);
-
-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}`);
-}
-
-if (ignorePatterns) {
-  console.log(`Ignore pattern: ${ignorePatterns}`);
-}
-
-if (askQuestion) {
-  console.log('Assistant can ask questions to the user');
-}

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');
-  });
-});