genaicode 0.0.31 → 0.0.32

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

@@ -21,5 +21,30 @@ describe('CLI Options', () => {
 
       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,7 +1,7 @@
 import fs from 'fs';
-
+import path from 'path';
 import { serviceAutoDetect } from './service-autodetect.js';
-import { rcConfig } from '../files/find-files.js';
+import { rcConfig } from '../main/config.js';
 
 const params = process.argv.slice(2);
 
@@ -19,12 +19,13 @@ 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 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.includes('--imagen');
+export const imagen = params.find((param) => param.startsWith('--imagen'))?.split('=')[1];
+export const cheap = params.includes('--cheap');
 
 // Add support for --help option
 export const helpRequested = params.includes('--help');
@@ -37,6 +38,9 @@ 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;
+
 if (taskFile) {
   if (explicitPrompt) {
     throw new Error('The --task-file option is exclusive with the --explicit-prompt option');
@@ -44,6 +48,9 @@ if (taskFile) {
   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.`;
 }
 
@@ -82,3 +89,11 @@ if (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}`);
+}

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

@@ -1,3 +1,7 @@
+import fs from 'fs';
+import path from 'path';
+import { rcConfig } from '../main/config.js';
+
 // List of allowed CLI parameters
 const allowedParameters = [
   '--dry-run',
@@ -20,8 +24,10 @@ const allowedParameters = [
   '--disable-initial-lint',
   '--temperature=',
   '--vision',
-  '--imagen',
+  '--imagen=',
+  '--cheap',
   '--help',
+  '--content-mask=',
 ];
 
 /**
@@ -65,9 +71,30 @@ export function validateCliParams() {
     }
   }
 
+  // Validate --imagen parameter
+  const imagenParam = providedParameters.find((param) => param.startsWith('--imagen='));
+  if (imagenParam) {
+    const imagenValue = imagenParam.split('=')[1];
+    if (imagenValue !== 'vertex-ai' && imagenValue !== 'dall-e') {
+      throw new Error('Invalid --imagen value. It must be either "vertex-ai" or "dall-e".');
+    }
+  }
+
   if (providedParameters.includes('--vision') && providedParameters.includes('--vertex-ai')) {
     throw new Error('--vision and --vertex-ai are currently not supported together.');
   }
+
+  // Validate content mask parameter
+  const contentMaskParam = providedParameters.find((param) => param.startsWith('--content-mask='));
+  if (contentMaskParam) {
+    const contentMaskValue = contentMaskParam.split('=')[1];
+    const fullPath = path.join(rcConfig.rootDir, contentMaskValue);
+    if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
+      throw new Error(
+        `Invalid --content-mask value. The path "${contentMaskValue}" does not exist or is not a directory within the project.`,
+      );
+    }
+  }
 }
 
 /**

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

@@ -43,6 +43,27 @@ describe('validateCliParams', () => {
 
     expect(() => validateCliParams()).toThrow('--vision and --vertex-ai are currently not supported together.');
   });
+
+  // New tests for --imagen parameter
+  it('should not throw for valid --imagen parameter with vertex-ai', () => {
+    process.argv.push('--imagen=vertex-ai');
+    expect(() => validateCliParams()).not.toThrow();
+  });
+
+  it('should not throw for valid --imagen parameter with dall-e', () => {
+    process.argv.push('--imagen=dall-e');
+    expect(() => validateCliParams()).not.toThrow();
+  });
+
+  it('should throw for invalid --imagen parameter value', () => {
+    process.argv.push('--imagen=invalid-service');
+    expect(() => validateCliParams()).toThrow('Invalid --imagen value. It must be either "vertex-ai" or "dall-e".');
+  });
+
+  it('should throw for --imagen parameter without value', () => {
+    process.argv.push('--imagen=');
+    expect(() => validateCliParams()).toThrow('Invalid --imagen value. It must be either "vertex-ai" or "dall-e".');
+  });
 });
 
 describe('getCliParamValue', () => {
@@ -74,6 +95,11 @@ describe('getCliParamValue', () => {
     process.argv.push('--temperature=0.5');
     expect(getCliParamValue('--temperature')).toBe('0.5');
   });
+
+  it('should return the value for --imagen parameter', () => {
+    process.argv.push('--imagen=vertex-ai');
+    expect(getCliParamValue('--imagen')).toBe('vertex-ai');
+  });
 });
 
 describe('hasCliParam', () => {
@@ -100,4 +126,9 @@ describe('hasCliParam', () => {
     process.argv.push('--temperature=0.5');
     expect(hasCliParam('--temperature')).toBe(true);
   });
+
+  it('should return true for --imagen parameter', () => {
+    process.argv.push('--imagen=dall-e');
+    expect(hasCliParam('--imagen')).toBe(true);
+  });
 });

package/src/files/file-utils.js

@@ -0,0 +1,7 @@
+import path from 'path';
+
+/** 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/file-utils.test.js

@@ -0,0 +1,21 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { isAncestorDirectory } from './file-utils.js';
+
+// Test for isAncestorDirectory
+describe('isAncestorDirectory', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should return true if directories are the same', () => {
+    expect(isAncestorDirectory('/project', '/project')).toBe(true);
+  });
+
+  it('should return true if parent is ancestor of dir', () => {
+    expect(isAncestorDirectory('/project', '/project/src')).toBe(true);
+  });
+
+  it('should return false if parent is not ancestor of dir', () => {
+    expect(isAncestorDirectory('/project', '/other')).toBe(false);
+  });
+});

package/src/files/find-files.js

@@ -1,73 +1,17 @@
 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();
+import { rcConfig, sourceExtensions, IMAGE_ASSET_EXTENSIONS, ignorePaths } from '../main/config.js';
 
 // 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))) {
+    if (ignorePaths.some((ignorePath) => fullPath.endsWith(ignorePath))) {
       continue;
     }
 
@@ -127,22 +71,16 @@ export function getDependencyList(entryFile) {
   return Array.from(result);
 }
 
-const sourceFiles = findFiles(rootDir, true, sourceExtensions);
+const sourceFiles = findFiles(rcConfig.rootDir, true, sourceExtensions);
 
 /** Get source files of the application */
 export function getSourceFiles() {
   return [...sourceFiles];
 }
 
-const imageAssetFiles = findFiles(rootDir, true, IMAGE_ASSET_EXTENSIONS);
+const imageAssetFiles = findFiles(rcConfig.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

@@ -1,9 +1,12 @@
 import fs from 'fs';
 import mime from 'mime-types';
 import sizeOf from 'image-size';
+import path from 'path';
 
 import { getSourceFiles, getImageAssetFiles } from './find-files.js';
+import { rcConfig } from '../main/config.js';
 import { verifySourceCodeLimit } from '../prompt/limits.js';
+import { taskFile, contentMask } from '../cli/cli-params.js';
 
 /**
  * Read contents of source files and create a map with file path as key and file content as value
@@ -12,7 +15,16 @@ function readSourceFiles(filterPaths) {
   const sourceCode = {};
   for (const file of getSourceFiles()) {
     if (!filterPaths || filterPaths.includes(file)) {
-      sourceCode[file] = fs.readFileSync(file, 'utf-8');
+      // Apply content mask filter if it's set
+      if (!filterPaths && contentMask) {
+        const relativePath = path.relative(rcConfig.rootDir, file);
+        if (!relativePath.startsWith(contentMask)) {
+          sourceCode[file] = { content: null }; // Include the file path but set content to null
+          continue;
+        }
+      }
+      const content = fs.readFileSync(file, 'utf-8');
+      sourceCode[file] = { content };
     }
   }
   return sourceCode;
@@ -21,6 +33,13 @@ function readSourceFiles(filterPaths) {
 /** Print source code of all source files */
 export function getSourceCode(filterPaths) {
   const sourceCode = readSourceFiles(filterPaths);
+
+  if (taskFile && !sourceCode[taskFile]) {
+    sourceCode[taskFile] = {
+      content: fs.readFileSync(taskFile, 'utf-8'),
+    };
+  }
+
   verifySourceCodeLimit(JSON.stringify(sourceCode));
   return sourceCode;
 }

package/src/files/read-files.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import mime from 'mime-types';
+import sizeOf from 'image-size';
+import { getSourceCode, getImageAssets } from './read-files.js';
+import { getSourceFiles, getImageAssetFiles } from './find-files.js';
+import { verifySourceCodeLimit } from '../prompt/limits.js';
+import * as cliParams from '../cli/cli-params.js';
+import { rcConfig } from '../main/config.js';
+
+vi.mock('fs');
+vi.mock('mime-types');
+vi.mock('image-size');
+vi.mock('./find-files.js', () => ({
+  getImageAssetFiles: vi.fn(),
+  getSourceFiles: vi.fn(),
+}));
+vi.mock('../prompt/limits.js');
+vi.mock('../cli/cli-params.js', () => ({
+  taskFile: null,
+  contentMask: null,
+}));
+vi.mock('../main/config.js', () => ({
+  rcConfig: { rootDir: '/home/project' },
+}));
+
+describe('read-files', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(cliParams).contentMask = undefined;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getSourceCode', () => {
+    it('should return source code for all files', () => {
+      const mockFiles = ['/home/project/file1.js', '/home/project/file2.js'];
+      getSourceFiles.mockReturnValue(mockFiles);
+      fs.readFileSync.mockImplementation((file) => `Content of ${file}`);
+      rcConfig.rootDir = '/home/project';
+
+      const result = getSourceCode();
+
+      expect(result).toEqual({
+        '/home/project/file1.js': { content: 'Content of /home/project/file1.js' },
+        '/home/project/file2.js': { content: 'Content of /home/project/file2.js' },
+      });
+      expect(verifySourceCodeLimit).toHaveBeenCalled();
+    });
+
+    it('should apply content mask when specified', () => {
+      const mockFiles = ['/home/project/file1.js', '/home/project/subfolder/file2.js'];
+      getSourceFiles.mockReturnValue(mockFiles);
+      fs.readFileSync.mockImplementation((file) => `Content of ${file}`);
+      rcConfig.rootDir = '/home/project';
+      vi.mocked(cliParams).contentMask = 'subfolder';
+
+      const result = getSourceCode();
+
+      expect(result).toEqual({
+        '/home/project/file1.js': { content: null },
+        '/home/project/subfolder/file2.js': {
+          content: 'Content of /home/project/subfolder/file2.js',
+        },
+      });
+    });
+
+    it('should include task file when specified', () => {
+      const mockFiles = ['/home/project/file1.js'];
+      getSourceFiles.mockReturnValue(mockFiles);
+      fs.readFileSync.mockImplementation((file) => `Content of ${file}`);
+      rcConfig.rootDir = '/home/project';
+      vi.mocked(cliParams).taskFile = '/home/project/task.md';
+
+      const result = getSourceCode();
+
+      expect(result).toEqual({
+        '/home/project/file1.js': { content: 'Content of /home/project/file1.js' },
+        '/home/project/task.md': { content: 'Content of /home/project/task.md' },
+      });
+    });
+  });
+
+  describe('getImageAssets', () => {
+    it('should return image assets information', () => {
+      const mockImageFiles = ['/home/project/image1.png', '/home/project/image2.jpg'];
+      getImageAssetFiles.mockReturnValue(mockImageFiles);
+      mime.lookup.mockImplementation((file) => (file.endsWith('.png') ? 'image/png' : 'image/jpeg'));
+      sizeOf.mockImplementation(() => ({ width: 100, height: 200 }));
+
+      const result = getImageAssets();
+
+      expect(result).toEqual({
+        '/home/project/image1.png': { mimeType: 'image/png', width: 100, height: 200 },
+        '/home/project/image2.jpg': { mimeType: 'image/jpeg', width: 100, height: 200 },
+      });
+      expect(verifySourceCodeLimit).toHaveBeenCalled();
+    });
+  });
+});

package/src/files/temp-buffer.js

@@ -0,0 +1,13 @@
+/** Temporary storage */
+let tempId = 1;
+const temp = {};
+
+export function getTempBuffer(url) {
+  return temp[url];
+}
+
+export function setTempBuffer(buffer) {
+  const imageUrl = 'temp://' + tempId++;
+  temp[imageUrl] = buffer;
+  return imageUrl;
+}

package/src/files/update-files.js

@@ -3,7 +3,9 @@ import path from 'path';
 import assert from 'node:assert';
 import * as diff from 'diff';
 
-import { isAncestorDirectory, getSourceFiles, rootDir } from './find-files.js';
+import { getSourceFiles } from './find-files.js';
+import { isAncestorDirectory } from './file-utils.js';
+import { rcConfig } from '../main/config.js';
 import {
   allowDirectoryCreate,
   allowFileCreate,
@@ -13,29 +15,61 @@ import {
   chatGpt,
   vertexAiClaude,
 } from '../cli/cli-params.js';
+import { getTempBuffer } from './temp-buffer.js';
+import { imglyRemoveBackground } from '../images/imgly-remove-background.js';
+import { splitImage } from '../images/split-image.js';
+import { resizeImageFile } from '../images/resize-image.js';
 
 /**
  * @param functionCalls Result of the code generation, a map of file paths to new content
  */
 export async function updateFiles(functionCalls) {
   for (const { name, args } of functionCalls) {
-    let { filePath, newContent, source, destination, patch } = args;
+    let {
+      filePath,
+      newContent,
+      source,
+      destination,
+      patch,
+      inputFilePath,
+      outputFilePath,
+      backgroundColor,
+      parts,
+      size,
+    } = args;
 
     // Check if filePath is absolute, if not use rootDir as baseline
-    if (name !== 'moveFile') {
-      filePath = path.isAbsolute(filePath) ? filePath : path.join(rootDir, filePath);
-    } else {
-      source = path.isAbsolute(source) ? source : path.join(rootDir, source);
-      destination = path.isAbsolute(destination) ? destination : path.join(rootDir, destination);
+    if (name !== 'moveFile' && name !== 'imglyRemoveBackground' && name !== 'splitImage') {
+      filePath = path.isAbsolute(filePath) ? filePath : path.join(rcConfig.rootDir, filePath);
+    } else if (name === 'moveFile') {
+      source = path.isAbsolute(source) ? source : path.join(rcConfig.rootDir, source);
+      destination = path.isAbsolute(destination) ? destination : path.join(rcConfig.rootDir, destination);
+    } else if (name === 'imglyRemoveBackground' || name === 'splitImage') {
+      inputFilePath = path.isAbsolute(inputFilePath) ? inputFilePath : path.join(rcConfig.rootDir, inputFilePath);
+      if (name === 'imglyRemoveBackground') {
+        outputFilePath = path.isAbsolute(outputFilePath) ? outputFilePath : path.join(rcConfig.rootDir, outputFilePath);
+      } else if (name === 'splitImage') {
+        parts.forEach(
+          (part) =>
+            (part.outputFilePath = path.isAbsolute(part.outputFilePath)
+              ? part.outputFilePath
+              : path.join(rcConfig.rootDir, part.outputFilePath)),
+        );
+      }
     }
 
     // ignore files which are not located inside project directory (sourceFiles)
     if (
-      (name !== 'moveFile' && !isProjectPath(filePath)) ||
-      (name === 'moveFile' && (!isProjectPath(source) || !isProjectPath(destination)))
+      (name !== 'moveFile' && name !== 'imglyRemoveBackground' && name !== 'splitImage' && !isProjectPath(filePath)) ||
+      (name === 'moveFile' && (!isProjectPath(source) || !isProjectPath(destination))) ||
+      (name === 'imglyRemoveBackground' && (!isProjectPath(inputFilePath) || !isProjectPath(outputFilePath))) ||
+      (name === 'splitImage' &&
+        (!isProjectPath(inputFilePath) || parts.some((part) => !isProjectPath(part.outputFilePath))))
     ) {
-      console.log(`Skipping file: ${filePath || source}`);
-      throw new Error(`File ${filePath || source} is not located inside project directory, something is wrong?`);
+      console.log(`Skipping file: ${filePath || source || inputFilePath}`);
+      throw new Error(
+        `File ${filePath || source || inputFilePath} is not located inside project directory, something is wrong?`,
+      );
     }
 
     if (name === 'deleteFile') {
@@ -90,15 +124,68 @@ export async function updateFiles(functionCalls) {
       }
       try {
         assert(args.downloadUrl, 'image url is not empty');
-        const imageResponse = await fetch(args.downloadUrl);
-        const arrayBuffer = await imageResponse.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        fs.writeFileSync(filePath, buffer);
+        if (args.downloadUrl.startsWith('temp://')) {
+          assert(getTempBuffer(args.downloadUrl), 'Temp buffer not present but expected');
+          fs.writeFileSync(filePath, getTempBuffer(args.downloadUrl));
+        } else {
+          const imageResponse = await fetch(args.downloadUrl);
+          const arrayBuffer = await imageResponse.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          fs.writeFileSync(filePath, buffer);
+        }
         console.log(`Image download and saved to: ${filePath}`);
       } catch (error) {
         console.error(`Failed to download image: ${error.message}`);
         throw error;
       }
+    } else if (name === 'imglyRemoveBackground') {
+      console.log(`Removing background from image: ${inputFilePath}`);
+      assert(fs.existsSync(inputFilePath), 'Input file does not exist');
+      assert(
+        allowFileCreate || fs.existsSync(outputFilePath),
+        'File create option was not enabled and output file does not exist',
+      );
+      if (allowDirectoryCreate) {
+        fs.mkdirSync(path.dirname(outputFilePath), { recursive: true });
+      }
+      try {
+        await imglyRemoveBackground(inputFilePath, outputFilePath, backgroundColor);
+        console.log(`Background removed and image saved to: ${outputFilePath}`);
+      } catch (error) {
+        console.error(`Failed to remove background: ${error.message}`);
+        throw error;
+      }
+    } else if (name === 'splitImage') {
+      console.log(`Splitting image: ${inputFilePath}`, parts);
+      assert(fs.existsSync(inputFilePath), 'Input file does not exist');
+      assert(Array.isArray(parts) && parts.length > 0, 'Parts array must not be empty');
+      for (const part of parts) {
+        assert(
+          allowFileCreate || fs.existsSync(part.outputFilePath),
+          'File create option was not enabled and output file does not exist',
+        );
+        if (allowDirectoryCreate) {
+          fs.mkdirSync(path.dirname(part.outputFilePath), { recursive: true });
+        }
+      }
+      try {
+        await splitImage(inputFilePath, parts);
+        console.log(`Image split successfully`);
+      } catch (error) {
+        console.error(`Failed to split image: ${error.message}`);
+        throw error;
+      }
+    } else if (name === 'resizeImage') {
+      console.log(`Resizing image: ${filePath}`, size);
+      assert(fs.existsSync(filePath), 'Input file does not exist');
+
+      try {
+        await resizeImageFile(filePath, size);
+        console.log(`Image resized successfully`);
+      } catch (error) {
+        console.error(`Failed to resize image: ${error.message}`);
+        throw error;
+      }
     }
   }
 }
@@ -107,7 +194,7 @@ function isProjectPath(filePath) {
   const sourceFiles = getSourceFiles();
 
   return (
-    isAncestorDirectory(rootDir, filePath) ||
+    isAncestorDirectory(rcConfig.rootDir, filePath) ||
     sourceFiles.includes(filePath) ||
     !sourceFiles.some(
       (sourceFile) =>

package/src/images/ensure-alpha.js

@@ -0,0 +1,5 @@
+import sharp from 'sharp';
+
+export async function ensureAlpha(image) {
+  return sharp(image).ensureAlpha().toBuffer();
+}

package/src/images/imgly-remove-background.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import { createRequire } from 'node:module';
+
+import { removeBackground } from '@imgly/background-removal-node';
+
+/** Converts white color to transparency on a image and saves to destination path */
+export async function imglyRemoveBackground(inputFilePath, outputFilePath) {
+  try {
+    console.log(`Removing background for image: ${inputFilePath}`);
+
+    const publicPath = 'file://' + createRequire(import.meta.url).resolve('@imgly/background-removal-node');
+    const blob = await removeBackground(inputFilePath, {
+      publicPath,
+    });
+    fs.writeFileSync(outputFilePath, Buffer.from(await blob.arrayBuffer()));
+
+    console.log(`Background removed successfully. Saved to: ${outputFilePath}`);
+    return outputFilePath;
+  } catch (error) {
+    console.error('Error removing background:', error);
+    throw error;
+  }
+}