genaicode 0.0.37 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genaicode",
-  "version": "0.0.37",
+  "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,6 +43,8 @@
     "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": {
@@ -47,7 +52,11 @@
     "@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",

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,126 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { printTokenUsageAndCost, processFunctionCalls } from './common.js';
-import { disableCache } from '../cli/cli-params.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' + (!disableCache ? ',prompt-caching-2024-07-31' : ''),
-    },
-  });
-
-  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,
-              ...(item.cache && !disableCache ? { cache_control: { type: 'ephemeral' } } : {}),
-            },
-          ],
-        };
-      } 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}`);
-
-  let retryCount = 0;
-  let response;
-  while (retryCount < 3) {
-    try {
-      response = await anthropic.beta.promptCaching.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,
-      });
-      break; // Exit loop if successful
-    } catch (error) {
-      if (error.headers?.['retry-after']) {
-        let retryAfter;
-        if (error.headers['retry-after'] === '0') {
-          retryAfter = (new Date(error.headers['anthropic-ratelimit-tokens-reset']).getTime() - Date.now()) / 1000;
-        } else {
-          retryAfter = Math.max(parseInt(error.headers['retry-after'], 10), 10);
-        }
-        console.log(`Rate limited. Retrying after ${retryAfter} seconds. Attempt ${retryCount + 1} of 3.`);
-        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
-        retryCount++;
-      } else {
-        console.error('An error occurred:', error);
-        throw error; // Re-throw the error if it's not a rate limit error
-      }
-    }
-  }
-
-  if (retryCount === 3) {
-    console.error('Failed to complete request after 3 attempts due to rate limiting.');
-    throw new Error('Rate limit exceeded. Operation aborted.');
-  }
-
-  // Print token usage for Anthropic
-  const usage = {
-    cacheCreateTokens: response.usage.cache_creation_input_tokens,
-    cacheReadTokens: response.usage.cache_read_input_tokens,
-    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,126 +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}`);
-
-  let retryCount = 0;
-  let response;
-  while (retryCount < 3) {
-    try {
-      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,
-      });
-      break; // Exit loop if successful
-    } catch (error) {
-      if (error.response?.headers?.['x-ratelimit-limit-tokens']) {
-        const rateLimitTokens = parseInt(error.response.headers['x-ratelimit-limit-tokens'], 10);
-        const retryAfter = error.response.headers['retry-after']
-          ? parseInt(error.response.headers['retry-after'], 10)
-          : 1;
-        console.log(
-          `Rate limited. Token limit: ${rateLimitTokens}. Retrying after ${retryAfter} seconds. Attempt ${retryCount + 1} of 3.`,
-        );
-        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
-        retryCount++;
-      } else {
-        console.error('An error occurred:', error);
-        throw error; // Re-throw the error if it's not a rate limit error
-      }
-    }
-  }
-
-  if (retryCount === 3) {
-    console.error('Failed to complete request after 3 attempts due to rate limiting.');
-    throw new Error('Rate limit exceeded. Operation aborted.');
-  }
-
-  // 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,49 +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);
-  if (usage.cacheCreateTokens) {
-    console.log('  - Cache create tokens: ', usage.cacheCreateTokens);
-  }
-  if (usage.cacheReadTokens) {
-    console.log('  - Cache read tokens: ', usage.cacheReadTokens);
-  }
-
-  const inputCost =
-    usage.inputTokens * inputCostPerToken +
-    (usage.cacheCreateTokens ?? 0) * inputCostPerToken * 1.25 +
-    (usage.cacheReadTokens ?? 0) * inputCostPerToken * 0.2;
-  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);
-}