genaicode 0.0.31

package/src/ai-service/dall-e.js

@@ -0,0 +1,29 @@
+import OpenAI from 'openai';
+
+/**
+ * Generate an image using OpenAI's DALL-E model and save it to a file
+ * @param {string} prompt - The description of the image to generate
+ * @param {string} size - The size of the image to generate ('256x256', '512x512', or '1024x1024')
+ * @returns {Promise<string>} - The url of the image
+ */
+export async function generateImage(prompt, size = '1024x1024') {
+  const openai = new OpenAI();
+
+  try {
+    const response = await openai.images.generate({
+      model: 'dall-e-3',
+      prompt: prompt,
+      n: 1,
+      size: size,
+      response_format: 'url',
+    });
+
+    const imageUrl = response.data[0].url;
+
+    console.log(`Image generated, url: ${imageUrl}`);
+    return imageUrl;
+  } catch (error) {
+    console.error('Error generating image:', error);
+    throw error;
+  }
+}

package/src/ai-service/function-calling.js

@@ -0,0 +1,320 @@
+import { requireExplanations, temperature } from '../cli/cli-params.js';
+
+/**
+ * Function definitions for function calling feature
+ */
+export const functionDefs = [
+  {
+    name: 'getSourceCode',
+    description:
+      'This function returns source code of the application in Map format, where absolute file path is the key, and file content is the value. This function can be called only once during the conversation, and only if suggested by the user.',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePaths: {
+          type: 'array',
+          description: 'An array of absolute paths of files that should be used to provided context.',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: 'getImageAssets',
+    description:
+      'This function returns a map of application image assets. This map contains absolute file path, and basic metadata information. It does not contain contents. Contents must be requested using dedicated tool.',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePaths: {
+          type: 'array',
+          description: 'An array of absolute paths of files that should be used to provided context.',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: 'codegenSummary',
+    description:
+      'This function is called with a summary of proposed updates. It contains a list of file paths that will be subject to code generation request, and also a list of file paths that make sense to use as a context for code generation requests.',
+    parameters: {
+      type: 'object',
+      properties: {
+        files: {
+          type: 'array',
+          description: 'An array of proposed file updates.',
+          items: {
+            type: 'object',
+            description: 'Proposed update of a file, the path, and the method of update',
+            properties: {
+              path: { type: 'string', description: 'An absolute path of the project file that will be updated' },
+              updateToolName: {
+                type: 'string',
+                enum: [
+                  'updateFile',
+                  'patchFile',
+                  'createFile',
+                  'deleteFile',
+                  'createDirectory',
+                  'moveFile',
+                  'generateImage',
+                  'downloadFile',
+                ],
+                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 more creative solution, the value should be lower, but stil within [0.0, 2.0] range. The default value is: ' +
+                  temperature,
+              },
+              prompt: {
+                type: 'string',
+                description:
+                  'Prompt that will be added to the LLM request together with the tool request. It summarizes the planned changes for this particular file.',
+              },
+              contextImageAssets: {
+                type: 'array',
+                description:
+                  'A list of of absolute image asset paths that should be included to the context of LLm request',
+                items: { type: 'string' },
+              },
+            },
+            required: ['path', 'updateToolName', 'temperature', 'prompt', 'contextImageAssets'],
+          },
+        },
+        contextPaths: {
+          type: 'array',
+          description:
+            'An array of absolute paths of files that should be used to provided context. 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',
+          },
+        },
+        explanation: {
+          type: 'string',
+          description: 'Explanation of planned changes or explanation of reasoning for no code changes',
+        },
+      },
+      required: ['files', 'contextPaths', 'explanation'],
+    },
+  },
+  {
+    name: 'updateFile',
+    description:
+      'Update a file with new content. The file must already exists in the application source code. The function should be called only if there is a need to actually change something.',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: {
+          type: 'string',
+          description: 'The file path to update.',
+        },
+        newContent: {
+          type: 'string',
+          description: 'The content to update the file with. Must not be empty.',
+        },
+        explanation: {
+          type: 'string',
+          description: 'The explanation of the reasoning behind the suggested code changes for this file',
+        },
+      },
+      required: ['filePath', 'newContent'],
+    },
+  },
+  {
+    name: 'patchFile',
+    description:
+      'Partially update a file content. The file must already exists in the application source code. The function should be called only if there is a need to actually change something.',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: {
+          type: 'string',
+          description: 'The file path to patch.',
+        },
+        patch: {
+          type: 'string',
+          description: `Modification to the file expressed in patch format. Example patch:
+
+\`\`\`
+Index: filename.js
+===================================================================
+--- filename.js
++++ filename.js
+@@ -1,2 +1,3 @@
+ line1
++line3
+ line2
+\
+\`\`\`
+          `,
+        },
+        explanation: {
+          type: 'string',
+          description: 'The explanation of the reasoning behind the suggested code changes for this file',
+        },
+      },
+      required: ['filePath', 'patch'],
+    },
+  },
+  {
+    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: 'The file path to create.',
+        },
+        newContent: {
+          type: 'string',
+          description: 'The content for the new file.',
+        },
+        explanation: {
+          type: 'string',
+          description: 'The explanation of the reasoning behind creating this file',
+        },
+      },
+      required: ['filePath', 'newContent'],
+    },
+  },
+  {
+    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'],
+    },
+  },
+  {
+    name: 'explanation',
+    description: 'Explain the reasoning behind the suggested code changes or reasoning for lack of code changes',
+    parameters: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string',
+          description: 'The explanation text',
+        },
+      },
+      required: ['text'],
+    },
+  },
+  {
+    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'],
+    },
+  },
+  {
+    name: 'moveFile',
+    description: 'Move a file from one location to another',
+    parameters: {
+      type: 'object',
+      properties: {
+        source: {
+          type: 'string',
+          description: 'The current file path.',
+        },
+        destination: {
+          type: 'string',
+          description: 'The new file path.',
+        },
+        explanation: {
+          type: 'string',
+          description: 'The explanation of the reasoning behind moving this file',
+        },
+      },
+      required: ['source', 'destination'],
+    },
+  },
+  {
+    name: 'generateImage',
+    description: 'Generate an image using AI service and save it as a file.',
+    parameters: {
+      type: 'object',
+      properties: {
+        prompt: {
+          type: 'string',
+          description: 'The prompt to generate the image.',
+        },
+        filePath: {
+          type: 'string',
+          description: 'The file path to save the generated image.',
+        },
+        size: {
+          type: 'string',
+          enum: ['256x256', '512x512', '1024x1024'],
+          description: 'The size of the image to generate.',
+        },
+        explanation: {
+          type: 'string',
+          description: 'The explanation of the reasoning behind generating this image',
+        },
+      },
+      required: ['prompt', 'filePath', 'size'],
+    },
+  },
+  {
+    name: 'downloadFile',
+    description: 'Download file from url, and save to file',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: {
+          type: 'string',
+          description: 'The file path to save the downloaded file.',
+        },
+        downloadUrl: {
+          type: 'string',
+          description: 'The url of the file that will be used for downloading.',
+        },
+        explanation: {
+          type: 'string',
+          description: 'The reasoning behind downloading this image.',
+        },
+      },
+      required: ['filePath', 'downloadUrl'],
+    },
+  },
+].map((fd) => {
+  if (requireExplanations && fd.parameters.properties.explanation && !fd.parameters.required.includes('explanation')) {
+    fd.parameters.required.push('explanation');
+  } else if (!requireExplanations) {
+    delete fd.parameters.properties.explanation;
+  }
+
+  return fd;
+});

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

@@ -0,0 +1,95 @@
+import { AnthropicVertex } from '@anthropic-ai/vertex-sdk';
+import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
+
+/**
+ * This function generates content using the Anthropic Claude model via Vertex AI.
+ */
+export async function generateContent(prompt, functionDefs, requiredFunctionName, temperature) {
+  const projectId = process.env.GOOGLE_CLOUD_PROJECT;
+  const region = process.env.GOOGLE_CLOUD_REGION;
+
+  if (!projectId || !region) {
+    throw new Error('GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_REGION environment variables must be set');
+  }
+
+  const client = new AnthropicVertex({
+    projectId,
+    region,
+  });
+
+  const messages = prompt
+    .filter((item) => item.type !== 'systemPrompt')
+    .map((item) => {
+      if (item.type === 'user') {
+        return {
+          role: 'user',
+          content: [
+            ...(item.functionResponses ?? []).map((response) => ({
+              type: 'tool_result',
+              tool_use_id: response.call_id ?? response.name,
+              content: response.content,
+            })),
+            ...(item.images ?? []).map((image) => ({
+              type: 'image',
+              source: {
+                type: 'base64',
+                media_type: image.mediaType,
+                data: image.base64url,
+              },
+            })),
+            { type: 'text', text: item.text },
+          ],
+        };
+      } else if (item.type === 'assistant') {
+        return {
+          role: 'assistant',
+          content: [
+            ...(item.text ? [{ type: 'text', text: item.text }] : []),
+            ...item.functionCalls.map((call) => ({
+              type: 'tool_use',
+              id: call.id ?? call.name,
+              name: call.name,
+              input: call.args ?? {},
+            })),
+          ],
+        };
+      }
+    });
+
+  const response = await client.messages.create({
+    model: 'claude-3-5-sonnet@20240620',
+    max_tokens: 4096,
+    temperature: temperature,
+    system: prompt.find((item) => item.type === 'systemPrompt').systemPrompt,
+    messages,
+    tools: functionDefs.map((fd) => ({
+      name: fd.name,
+      description: fd.description,
+      input_schema: fd.parameters,
+    })),
+    tool_choice: requiredFunctionName ? { type: 'tool', name: requiredFunctionName } : { type: 'any' },
+  });
+
+  // Print token usage for Anthropic Vertex AI
+  const usage = {
+    inputTokens: response.usage.input_tokens,
+    outputTokens: response.usage.output_tokens,
+    totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+  };
+  printTokenUsageAndCost(usage, 3 / 1000 / 1000, 15 / 1000 / 1000);
+
+  const responseMessages = response.content.filter((item) => item.type !== 'tool_use');
+  if (responseMessages.length > 0) {
+    console.log('Response messages', responseMessages);
+  }
+
+  const functionCalls = response.content
+    .filter((item) => item.type === 'tool_use')
+    .map((item) => ({
+      id: item.id,
+      name: item.name,
+      args: item.input,
+    }));
+
+  return processFunctionCalls(functionCalls);
+}

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

@@ -0,0 +1,155 @@
+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) {
+  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,
+      },
+    ],
+    // TODO: add tool_config once [it is supported](https://github.com/googleapis/nodejs-vertexai/issues/331)
+    toolConfig: {
+      functionCallingConfig: {
+        mode: 'ANY',
+        ...(requiredFunctionName ? { allowedFunctionNames: [requiredFunctionName] } : {}),
+      },
+    },
+  };
+
+  const model = await getGenModel(prompt.find((item) => item.type === 'systemPrompt').systemPrompt, temperature);
+
+  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
+export function getGenModel(systemPrompt, temperature) {
+  // Initialize Vertex with your Cloud project and location
+  const vertex_ai = new VertexAI({});
+  const model = 'gemini-1.5-pro-001';
+
+  // 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

@@ -0,0 +1,106 @@
+// 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.',
+  },
+];
+
+/**
+ * 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 };