genaicode 0.0.31

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

@@ -0,0 +1,25 @@
+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();
+    });
+  });
+});

package/src/cli/cli-params.js

@@ -0,0 +1,84 @@
+import fs from 'fs';
+
+import { serviceAutoDetect } from './service-autodetect.js';
+import { rcConfig } from '../files/find-files.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 const 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.includes('--imagen');
+
+// 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
+
+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`);
+  }
+  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');
+}

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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,11 @@
+/** 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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,90 @@
+// 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',
+  '--help',
+];
+
+/**
+ * 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);
+    }
+  }
+
+  if (providedParameters.includes('--vision') && providedParameters.includes('--vertex-ai')) {
+    throw new Error('--vision and --vertex-ai are currently not supported together.');
+  }
+}
+
+/**
+ * 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);
+}

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

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { validateCliParams, getCliParamValue, hasCliParam } from './validate-cli-params.js';
+
+describe('validateCliParams', () => {
+  const originalArgv = process.argv;
+
+  beforeEach(() => {
+    process.argv = ['node', 'script.js'];
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+  });
+
+  it('should not throw for valid parameters', () => {
+    process.argv.push('--dry-run', '--consider-all-files');
+    expect(() => validateCliParams()).not.toThrow();
+  });
+
+  it('should throw for invalid parameters', () => {
+    process.argv.push('--invalid-param');
+    expect(() => validateCliParams()).toThrow();
+  });
+
+  it('should throw for parameters without --', () => {
+    process.argv.push('invalid-param');
+    expect(() => validateCliParams()).toThrow();
+  });
+
+  it('should not throw for valid --temperature parameter', () => {
+    process.argv.push('--temperature=0.5');
+    expect(() => validateCliParams()).not.toThrow();
+  });
+
+  it('should throw for invalid --temperature parameter', () => {
+    process.argv.push('--temperature=invalid');
+    expect(() => validateCliParams()).toThrow();
+  });
+
+  it('should throw an error when both vision and vertexAi flags are true', () => {
+    process.argv.push('--vision');
+    process.argv.push('--vertex-ai');
+
+    expect(() => validateCliParams()).toThrow('--vision and --vertex-ai are currently not supported together.');
+  });
+});
+
+describe('getCliParamValue', () => {
+  const originalArgv = process.argv;
+
+  beforeEach(() => {
+    process.argv = ['node', 'script.js'];
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+  });
+
+  it('should return the value for a parameter with a value', () => {
+    process.argv.push('--explicit-prompt=Test prompt');
+    expect(getCliParamValue('--explicit-prompt')).toBe('Test prompt');
+  });
+
+  it('should return null for a parameter without a value', () => {
+    process.argv.push('--dry-run');
+    expect(getCliParamValue('--dry-run')).toBeNull();
+  });
+
+  it('should return null for a non-existent parameter', () => {
+    expect(getCliParamValue('--non-existent')).toBeNull();
+  });
+
+  it('should return the value for --temperature parameter', () => {
+    process.argv.push('--temperature=0.5');
+    expect(getCliParamValue('--temperature')).toBe('0.5');
+  });
+});
+
+describe('hasCliParam', () => {
+  const originalArgv = process.argv;
+
+  beforeEach(() => {
+    process.argv = ['node', 'script.js'];
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+  });
+
+  it('should return true for an existing parameter', () => {
+    process.argv.push('--dry-run');
+    expect(hasCliParam('--dry-run')).toBe(true);
+  });
+
+  it('should return false for a non-existent parameter', () => {
+    expect(hasCliParam('--non-existent')).toBe(false);
+  });
+
+  it('should return true for --temperature parameter', () => {
+    process.argv.push('--temperature=0.5');
+    expect(hasCliParam('--temperature')).toBe(true);
+  });
+});

package/src/files/find-files.js

@@ -0,0 +1,148 @@
+import fs from 'fs';
+import path from 'path';
+import assert from 'node:assert';
+
+// This file contains project codegen configuration
+const CODEGENRC_FILENAME = '.genaicoderc';
+
+const cwd = process.cwd();
+
+// List of possible extensions for dependency resolution
+const POSSIBLE_DEPENDENCY_EXTENSIONS = ['.ts', '.js', '.tsx', '.jsx'];
+
+// Find .genaicoderc file
+let rcFilePath = cwd;
+while (!fs.existsSync(path.join(rcFilePath, CODEGENRC_FILENAME))) {
+  const parentDir = path.dirname(rcFilePath);
+  if (parentDir === rcFilePath) {
+    throw new Error(`${CODEGENRC_FILENAME} not found in any parent directory`);
+  }
+  rcFilePath = parentDir;
+}
+rcFilePath = path.join(rcFilePath, CODEGENRC_FILENAME);
+
+assert(fs.existsSync(rcFilePath), `${CODEGENRC_FILENAME} not found`);
+
+// Read rootDir and extensions from .genaicoderc
+export const rcConfig = JSON.parse(fs.readFileSync(rcFilePath, 'utf-8'));
+export const rootDir = path.resolve(path.dirname(rcFilePath), rcConfig.rootDir);
+
+assert(rootDir, 'Root dir not configured');
+assert(isAncestorDirectory(path.dirname(rcFilePath), rootDir), 'Root dir is not located inside project directory');
+
+console.log('Detected codegen configuration', rcConfig);
+console.log('Root dir:', rootDir);
+
+// Default extensions if not specified in .genaicoderc
+const DEFAULT_EXTENSIONS = [
+  '.md',
+  '.js',
+  '.ts',
+  '.tsx',
+  '.css',
+  '.scss',
+  '.py',
+  '.go',
+  '.c',
+  '.h',
+  '.cpp',
+  '.txt',
+  '.html',
+  '.txt',
+  '.json',
+];
+
+// Use extensions from .genaicoderc if available, otherwise use default
+const sourceExtensions = rcConfig.extensions || DEFAULT_EXTENSIONS;
+
+// Image extensions (driven by ai service limitations)
+const IMAGE_ASSET_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp'];
+
+// A list of paths that are ignored by default
+const DEFAULT_IGNORE_PATHS = ['node_modules', 'build', 'dist', 'package-lock.json', 'coverage'];
+
+function findFiles(dir, recursive, extensions) {
+  const files = [];
+  const items = fs.readdirSync(dir);
+  for (const item of items) {
+    const fullPath = path.join(dir, item);
+
+    if ((rcConfig.ignorePaths ?? DEFAULT_IGNORE_PATHS).some((ignorePath) => fullPath.endsWith(ignorePath))) {
+      continue;
+    }
+
+    if (fs.statSync(fullPath).isDirectory()) {
+      if (recursive) {
+        files.push(...findFiles(fullPath, true, extensions));
+      }
+    } else if (extensions.includes(path.extname(fullPath))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function getDependencies(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const dependencyRegex = /import\s+.+?\s+from\s+['"](.+?\/?[^'"]+)['"]/g;
+  const dependencies = [];
+  let match;
+  while ((match = dependencyRegex.exec(content)) !== null) {
+    const dependencyPath = match[1];
+    // Resolve relative paths from the file's directory
+    let resolvedPath = path.resolve(path.dirname(filePath), dependencyPath);
+
+    // Only add the dependency if it's a local file and not a module
+    if (fs.existsSync(resolvedPath)) {
+      dependencies.push(resolvedPath);
+    } else {
+      const possibleExtensions = POSSIBLE_DEPENDENCY_EXTENSIONS;
+      for (const ext of possibleExtensions) {
+        const extendedPath = resolvedPath + ext;
+        if (fs.existsSync(extendedPath)) {
+          dependencies.push(extendedPath);
+        }
+      }
+    }
+  }
+  return dependencies;
+}
+
+/** Generates a dependency list for given file */
+export function getDependencyList(entryFile) {
+  const visitedFiles = new Set();
+  const result = new Set();
+
+  function traverse(file) {
+    if (visitedFiles.has(file)) return;
+    visitedFiles.add(file);
+    const dependencies = getDependencies(file);
+    dependencies.forEach((dependency) => result.add(dependency));
+    dependencies.forEach(traverse);
+  }
+
+  result.add(path.resolve(entryFile));
+  traverse(entryFile);
+
+  return Array.from(result);
+}
+
+const sourceFiles = findFiles(rootDir, true, sourceExtensions);
+
+/** Get source files of the application */
+export function getSourceFiles() {
+  return [...sourceFiles];
+}
+
+const imageAssetFiles = findFiles(rootDir, true, IMAGE_ASSET_EXTENSIONS);
+
+/** Get source files of the application */
+export function getImageAssetFiles() {
+  return [...imageAssetFiles];
+}
+
+/** Check if directory is ancestor of given directory */
+export function isAncestorDirectory(parent, dir) {
+  const relative = path.relative(parent, dir);
+  return parent === dir || (relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}

package/src/files/read-files.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import mime from 'mime-types';
+import sizeOf from 'image-size';
+
+import { getSourceFiles, getImageAssetFiles } from './find-files.js';
+import { verifySourceCodeLimit } from '../prompt/limits.js';
+
+/**
+ * Read contents of source files and create a map with file path as key and file content as value
+ */
+function readSourceFiles(filterPaths) {
+  const sourceCode = {};
+  for (const file of getSourceFiles()) {
+    if (!filterPaths || filterPaths.includes(file)) {
+      sourceCode[file] = fs.readFileSync(file, 'utf-8');
+    }
+  }
+  return sourceCode;
+}
+
+/** Print source code of all source files */
+export function getSourceCode(filterPaths) {
+  const sourceCode = readSourceFiles(filterPaths);
+  verifySourceCodeLimit(JSON.stringify(sourceCode));
+  return sourceCode;
+}
+
+/** Get image asset files summary */
+export function getImageAssets() {
+  const imageAssets = {};
+  for (const file of getImageAssetFiles()) {
+    const dimensions = sizeOf(file);
+    imageAssets[file] = {
+      mimeType: mime.lookup(file),
+      width: dimensions.width,
+      height: dimensions.height,
+    };
+  }
+  verifySourceCodeLimit(JSON.stringify(imageAssets));
+  return imageAssets;
+}