genaicode 0.0.35 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genaicode",
-  "version": "0.0.35",
+  "version": "0.1.1",
   "author": "Grzegorz Tańczyk",
   "repository": {
     "type": "git",
@@ -19,17 +19,20 @@
   "license": "Apache-2.0",
   "files": [
     "bin",
-    "src",
+    "dist",
     "media",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "lint": "eslint . --ext js --report-unused-disable-directives --max-warnings 0",
+    "lint": "eslint . --ext js,ts --report-unused-disable-directives --max-warnings 0",
     "test": "vitest",
     "coverage": "vitest run --coverage",
     "prepare": "husky install",
-    "postinstall": "node ./bin/vertex-monkey-patch.cjs"
+    "postinstall": "node ./bin/vertex-monkey-patch.cjs",
+    "type-check": "tsc --noEmit",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^7.17.0",
@@ -40,15 +43,22 @@
     "husky": "^9.1.1",
     "lint-staged": "^15.2.7",
     "prettier": "^3.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.0.0",
     "vitest": "^2.0.4"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.24.3",
+    "@anthropic-ai/sdk": "^0.26.1",
     "@anthropic-ai/vertex-sdk": "^0.4.1",
     "@google-cloud/aiplatform": "^3.25.0",
     "@google-cloud/vertexai": "^1.3.0",
+    "@google/generative-ai": "^0.17.1",
     "@imgly/background-removal-node": "^1.4.5",
+    "@types/diff": "^5.2.1",
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "^18.0.0",
     "diff": "^5.2.0",
+    "glob-regex": "^0.3.2",
     "image-size": "^1.1.1",
     "jsonschema": "^1.4.1",
     "mime-types": "^2.1.35",

package/bin/genaicode.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-import { runCodegen } from '../src/main/codegen.js';
-
-await runCodegen();

package/src/ai-service/anthropic.js

@@ -1,95 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-
-/**
- * This function generates content using the Anthropic Claude model.
- */
-export async function generateContent(prompt, functionDefs, requiredFunctionName, temperature, cheap = false) {
-  const anthropic = new Anthropic({
-    defaultHeaders: {
-      'anthropic-beta': 'max-tokens-3-5-sonnet-2024-07-15',
-    },
-  });
-
-  const messages = prompt
-    .filter((item) => item.type !== 'systemPrompt')
-    .map((item) => {
-      if (item.type === 'user') {
-        return {
-          role: 'user',
-          content: [
-            ...(item.functionResponses ?? []).map((response) => ({
-              tool_use_id: response.call_id ?? response.name,
-              content: response.content,
-              type: 'tool_result',
-              is_error: response.isError === true,
-            })),
-            ...(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) => ({
-              id: call.id ?? call.name,
-              name: call.name,
-              input: call.args ?? {},
-              type: 'tool_use',
-            })),
-          ],
-        };
-      }
-    });
-
-  const model = cheap ? 'claude-3-haiku-20240307' : 'claude-3-5-sonnet-20240620';
-  console.log(`Using Anthropic model: ${model}`);
-
-  const response = await anthropic.messages.create({
-    model: model,
-    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' },
-    max_tokens: cheap ? 4096 : 8192,
-    temperature: temperature,
-  });
-
-  // Print token usage for Anthropic
-  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) => ({
-      name: item.name,
-      args: item.input,
-    }));
-
-  return processFunctionCalls(functionCalls);
-}

package/src/ai-service/chat-gpt.js

@@ -1,99 +0,0 @@
-import OpenAI from 'openai';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-
-/**
- * This function generates content using the OpenAI chat model.
- */
-export async function generateContent(prompt, functionDefs, requiredFunctionName, temperature, cheap = false) {
-  const openai = new OpenAI();
-
-  const messages = prompt
-    .map((item) => {
-      if (item.type === 'systemPrompt') {
-        return {
-          role: 'system',
-          content: item.systemPrompt,
-        };
-      } else if (item.type === 'user') {
-        return [
-          ...(item.functionResponses ?? []).map((response) => ({
-            role: 'tool',
-            name: response.name,
-            content: response.content ?? '',
-            tool_call_id: response.name,
-          })),
-          {
-            role: 'user',
-            content:
-              item.images?.length > 0
-                ? [
-                    ...item.images.map((image) => ({
-                      type: 'image_url',
-                      image_url: {
-                        url: 'data:' + image.mediaType + ';base64,' + image.base64url,
-                      },
-                    })),
-                    {
-                      type: 'text',
-                      text: item.text,
-                    },
-                  ]
-                : item.text,
-          },
-        ];
-      } else if (item.type === 'assistant') {
-        return {
-          role: 'assistant',
-          ...(item.text ? { content: item.text } : {}),
-          tool_calls: item.functionCalls.map((call) => ({
-            type: 'function',
-            function: { name: call.name, arguments: JSON.stringify(call.args ?? {}) },
-            id: call.name,
-          })),
-        };
-      }
-    })
-    .flat();
-
-  const model = cheap ? 'gpt-4o-mini' : 'gpt-4o-2024-08-06';
-  console.log(`Using OpenAI model: ${model}`);
-
-  const response = await openai.chat.completions.create({
-    model: model,
-    messages,
-    tools: functionDefs.map((funDef) => ({ type: 'function', function: funDef })),
-    tool_choice: requiredFunctionName ? { type: 'function', function: { name: requiredFunctionName } } : 'required',
-    temperature: temperature,
-  });
-
-  // Print token usage for chat gpt
-  const usage = {
-    inputTokens: response.usage.prompt_tokens,
-    outputTokens: response.usage.completion_tokens,
-    totalTokens: response.usage.total_tokens,
-  };
-  printTokenUsageAndCost(usage, 0.000005, 0.000015);
-
-  const responseMessage = response.choices[0].message;
-
-  if (responseMessage.content?.message) {
-    console.log('Message', responseMessage.content.message);
-  }
-
-  const toolCalls = responseMessage.tool_calls;
-  if (responseMessage.tool_calls) {
-    const functionCalls = toolCalls.map((call) => {
-      const name = call.function.name;
-      const args = JSON.parse(call.function.arguments);
-
-      return {
-        name,
-        args,
-      };
-    });
-
-    return processFunctionCalls(functionCalls);
-  } else {
-    throw new Error('No tool calls found in response');
-  }
-}

package/src/ai-service/common.js

@@ -1,40 +0,0 @@
-import assert from 'node:assert';
-import { functionDefs } from '../prompt/function-calling.js';
-
-/**
- * Common function to print token usage and estimated cost
- * @param {Object} usage Token usage object
- * @param {number} inputCostPerToken Cost per input token
- * @param {number} outputCostPerToken Cost per output token
- */
-export function printTokenUsageAndCost(usage, inputCostPerToken, outputCostPerToken) {
-  console.log('Token Usage:');
-  console.log('  - Input tokens: ', usage.inputTokens);
-  console.log('  - Output tokens: ', usage.outputTokens);
-  console.log('  - Total tokens: ', usage.totalTokens);
-
-  const inputCost = usage.inputTokens * inputCostPerToken;
-  const outputCost = usage.outputTokens * outputCostPerToken;
-  const totalCost = inputCost + outputCost;
-  console.log('  - Estimated cost: ', totalCost.toFixed(6), ' USD');
-}
-
-/**
- * Common function to process function calls and explanations
- * @param {Array} functionCalls Array of function calls
- * @returns {Array} Processed function calls
- */
-export function processFunctionCalls(functionCalls) {
-  const unknownFunctionCalls = functionCalls.filter((call) => !functionDefs.some((fd) => fd.name === call.name));
-  assert(
-    unknownFunctionCalls.length === 0,
-    'Unknown function name: ' + unknownFunctionCalls.map((call) => call.name).join(', '),
-  );
-
-  console.log(
-    'Explanations:',
-    functionCalls.filter((fn) => fn.name === 'explanation').map((call) => call.args.text),
-  );
-
-  return functionCalls; //.filter((fn) => fn.name !== 'explanation');
-}

package/src/ai-service/common.test.js

@@ -1,107 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-import { functionDefs } from '../prompt/function-calling.js';
-
-// Mock cli-params.js
-vi.mock('../cli/cli-params.js', () => ({
-  chatGpt: true,
-  anthropic: false,
-  vertexAi: false,
-  vertexAiClaude: false,
-  temperature: 0.7,
-  cheap: false,
-  geminiBlockNone: false,
-  requireExplanations: false,
-  vision: false,
-}));
-
-describe('printTokenUsageAndCost', () => {
-  let consoleLogSpy;
-
-  beforeEach(() => {
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleLogSpy.mockRestore();
-  });
-
-  it('should correctly log token usage and estimated cost', () => {
-    const usage = {
-      inputTokens: 100,
-      outputTokens: 50,
-      totalTokens: 150,
-    };
-    const inputCostPerToken = 0.0001;
-    const outputCostPerToken = 0.0002;
-
-    printTokenUsageAndCost(usage, inputCostPerToken, outputCostPerToken);
-
-    expect(consoleLogSpy).toHaveBeenCalledTimes(5);
-    expect(consoleLogSpy).toHaveBeenCalledWith('Token Usage:');
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Input tokens: ', 100);
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Output tokens: ', 50);
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Total tokens: ', 150);
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Estimated cost: ', '0.020000', ' USD');
-  });
-
-  it('should handle zero tokens correctly', () => {
-    const usage = {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0,
-    };
-    const inputCostPerToken = 0.0001;
-    const outputCostPerToken = 0.0002;
-
-    printTokenUsageAndCost(usage, inputCostPerToken, outputCostPerToken);
-
-    expect(consoleLogSpy).toHaveBeenCalledWith('  - Estimated cost: ', '0.000000', ' USD');
-  });
-});
-
-describe('processFunctionCalls', () => {
-  it('should process valid function calls correctly', () => {
-    const validFunctionCalls = [
-      { name: 'explanation', args: { text: 'This is an explanation' } },
-      { name: functionDefs[0].name, args: {} },
-    ];
-
-    const result = processFunctionCalls(validFunctionCalls);
-
-    expect(result).toEqual(validFunctionCalls);
-  });
-
-  it('should throw an error for unknown function names', () => {
-    const invalidFunctionCalls = [{ name: 'unknownFunction', args: {} }];
-
-    expect(() => processFunctionCalls(invalidFunctionCalls)).toThrow('Unknown function name: unknownFunction');
-  });
-
-  it('should correctly handle explanations', () => {
-    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    const functionCallsWithExplanation = [
-      { name: 'explanation', args: { text: 'This is an explanation' } },
-      { name: functionDefs[0].name, args: {} },
-    ];
-
-    processFunctionCalls(functionCallsWithExplanation);
-
-    expect(consoleLogSpy).toHaveBeenCalledWith('Explanations:', ['This is an explanation']);
-
-    consoleLogSpy.mockRestore();
-  });
-
-  it('should return all function calls including explanations', () => {
-    const functionCalls = [
-      { name: 'explanation', args: { text: 'This is an explanation' } },
-      { name: functionDefs[0].name, args: {} },
-    ];
-
-    const result = processFunctionCalls(functionCalls);
-
-    expect(result).toEqual(functionCalls);
-    expect(result.length).toBe(2);
-  });
-});

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

@@ -1,50 +0,0 @@
-import OpenAI, { toFile } from 'openai';
-
-import { setTempBuffer } from '../files/temp-buffer.js';
-import { resizeImageBuffer } from '../images/resize-image.js';
-import { ensureAlpha } from '../images/ensure-alpha.js';
-
-/**
- * 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|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 image
- */
-export async function generateImage(prompt, contextImagePath, size, cheap = false) {
-  const openai = new OpenAI();
-
-  try {
-    const model = contextImagePath ? 'dall-e-2' : cheap ? 'dall-e-2' : 'dall-e-3';
-    console.log(`Using DALL-E model: ${model}`);
-
-    const options = {
-      model: model,
-      prompt: prompt,
-      n: 1,
-      size: '1024x1024',
-      response_format: 'url',
-    };
-    const response = contextImagePath
-      ? await openai.images.edit({ ...options, image: await toFile(await ensureAlpha(contextImagePath)) })
-      : await openai.images.generate(options);
-
-    let imageUrl = response.data[0].url;
-
-    if ((size.width !== 1024) | (size.height !== 1024)) {
-      console.log('Resizing image to desired size', size);
-      const imageResponse = await fetch(imageUrl);
-      const arrayBuffer = await imageResponse.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-
-      imageUrl = setTempBuffer(await resizeImageBuffer(buffer, size));
-    }
-
-    console.log(`Image generated, url: ${imageUrl}`);
-    return imageUrl;
-  } catch (error) {
-    console.error('Error generating image:', error);
-    throw error;
-  }
-}

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

@@ -1,99 +0,0 @@
-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, cheap = false) {
-  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,
-              is_error: response.isError === true,
-            })),
-            ...(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 model = cheap ? 'claude-3-haiku@20240307' : 'claude-3-5-sonnet@20240620';
-  console.log(`Using Vertex AI Claude model: ${model}`);
-
-  const response = await client.messages.create({
-    model: model,
-    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-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;
-  }
-}