@tb.p/dd 1.0.0

package/utils/fileSystemUtils.js

@@ -0,0 +1,192 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+/**
+ * File System Utilities for @tb.p/dd
+ * Essential file system operations for scanning, moving, and managing files
+ */
+
+/**
+ * Check if a path exists (async)
+ * @param {string} filePath - Path to check
+ * @returns {Promise<boolean>} - True if path exists
+ */
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get file stats (async)
+ * @param {string} filePath - Path to file
+ * @returns {Promise<fs.Stats>} - File stats
+ */
+async function getFileStats(filePath) {
+  try {
+    return await fs.stat(filePath);
+  } catch (error) {
+    throw new Error(`Failed to get stats for ${filePath}: ${error.message}`);
+  }
+}
+
+/**
+ * Check if path is a directory
+ * @param {string} filePath - Path to check
+ * @returns {Promise<boolean>} - True if directory
+ */
+async function isDirectory(filePath) {
+  const stats = await getFileStats(filePath);
+  return stats.isDirectory();
+}
+
+/**
+ * Get file extension (without dot)
+ * @param {string} filePath - Path to file
+ * @returns {string} - File extension without dot
+ */
+function getFileExtension(filePath) {
+  return path.extname(filePath).toLowerCase().substring(1);
+}
+
+/**
+ * Normalize path separators for current OS
+ * @param {string} filePath - Path to normalize
+ * @returns {string} - Normalized path
+ */
+function normalizePath(filePath) {
+  return path.normalize(filePath);
+}
+
+/**
+ * Join paths safely
+ * @param {...string} paths - Paths to join
+ * @returns {string} - Joined path
+ */
+function joinPaths(...paths) {
+  return path.join(...paths);
+}
+
+/**
+ * Create directory recursively
+ * @param {string} dirPath - Directory path to create
+ * @returns {Promise<void>}
+ */
+async function createDirectory(dirPath) {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    throw new Error(`Failed to create directory ${dirPath}: ${error.message}`);
+  }
+}
+
+/**
+ * Remove file or directory
+ * @param {string} filePath - Path to remove
+ * @param {Object} options - Options
+ * @param {boolean} options.recursive - Remove recursively for directories
+ * @param {boolean} options.force - Force removal
+ * @returns {Promise<void>}
+ */
+async function removePath(filePath, options = {}) {
+  const { recursive = false, force = false } = options;
+
+  try {
+    const stats = await getFileStats(filePath);
+
+    if (stats.isDirectory()) {
+      if (recursive) {
+        await fs.rmdir(filePath, { recursive: true });
+      } else {
+        throw new Error(`Directory ${filePath} cannot be removed without recursive option`);
+      }
+    } else {
+      await fs.unlink(filePath);
+    }
+  } catch (error) {
+    if (force) {
+      console.warn(`Warning: Failed to remove ${filePath}: ${error.message}`);
+    } else {
+      throw new Error(`Failed to remove ${filePath}: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Copy file
+ * @param {string} src - Source file path
+ * @param {string} dest - Destination file path
+ * @param {Object} options - Options
+ * @param {boolean} options.overwrite - Overwrite if destination exists
+ * @returns {Promise<void>}
+ */
+async function copyFile(src, dest, options = {}) {
+  const { overwrite = false } = options;
+
+  if (!overwrite && await pathExists(dest)) {
+    throw new Error(`Destination file already exists: ${dest}`);
+  }
+
+  // Ensure destination directory exists
+  const destDir = path.dirname(dest);
+  await createDirectory(destDir);
+
+  try {
+    await fs.copyFile(src, dest);
+  } catch (error) {
+    throw new Error(`Failed to copy file from ${src} to ${dest}: ${error.message}`);
+  }
+}
+
+/**
+ * Move file
+ * @param {string} src - Source file path
+ * @param {string} dest - Destination file path
+ * @param {Object} options - Options
+ * @param {boolean} options.overwrite - Overwrite if destination exists
+ * @returns {Promise<void>}
+ */
+async function moveFile(src, dest, options = {}) {
+  const { overwrite = false } = options;
+
+  if (!overwrite && await pathExists(dest)) {
+    throw new Error(`Destination file already exists: ${dest}`);
+  }
+
+  // Ensure destination directory exists
+  const destDir = path.dirname(dest);
+  await createDirectory(destDir);
+
+  try {
+    await fs.rename(src, dest);
+  } catch (error) {
+    throw new Error(`Failed to move file from ${src} to ${dest}: ${error.message}`);
+  }
+}
+
+/**
+ * Get file size in bytes
+ * @param {string} filePath - Path to file
+ * @returns {Promise<number>} - File size in bytes
+ */
+async function getFileSize(filePath) {
+  const stats = await getFileStats(filePath);
+  return stats.size;
+}
+
+export {
+  pathExists,
+  getFileStats,
+  isDirectory,
+  getFileExtension,
+  normalizePath,
+  joinPaths,
+  createDirectory,
+  removePath,
+  copyFile,
+  moveFile,
+  getFileSize
+};

package/utils/index.js

@@ -0,0 +1,5 @@
+// Re-export all individual functions from each module
+export * from './fileSystemUtils.js';
+export * from './fileScanner.js';
+export * from './fileMover.js';
+export * from './fileHasher.js';

package/validators/optionValidator.js

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+function validatePath(path) {
+  try {
+    const stats = fs.statSync(path);
+    return stats.isDirectory();
+  } catch (error) {
+    return false;
+  }
+}
+
+function validateNewFilePath(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      return {
+        isValid: false,
+        error: `File already exists: ${filePath}`
+      };
+    }
+
+    const parentDir = path.dirname(filePath);
+    if (!fs.existsSync(parentDir)) {
+      return {
+        isValid: false,
+        error: `Parent directory does not exist: ${parentDir}`
+      };
+    }
+    try {
+      const testFile = path.join(parentDir, '.test-write-permission');
+      fs.writeFileSync(testFile, 'test');
+      fs.unlinkSync(testFile);
+    } catch (error) {
+      return {
+        isValid: false,
+        error: `Parent directory is not writable: ${parentDir}`
+      };
+    }
+
+    return { isValid: true };
+  } catch (error) {
+    return {
+      isValid: false,
+      error: `Invalid file path: ${filePath}`
+    };
+  }
+}
+
+function validateOptions(options) {
+  // Check if --targets was explicitly provided (not just the default)
+  // Commander.js sets the default value even when not explicitly provided
+  // We need to check if the raw targets value matches the default
+  const defaultTargets = process.cwd();
+  const targetsExplicitlyProvided = options._raw && 
+    options._raw.targets !== undefined && 
+    options._raw.targets !== defaultTargets;
+  
+  // Check for get-extensions mode or save mode
+  const isGetExtensionsMode = options.mode === 'get-extensions';
+  const isSaveMode = options.mode === 'save';
+  
+  if ((isGetExtensionsMode || isSaveMode) && !targetsExplicitlyProvided) {
+    console.error('Error: --targets is required when using --get-extensions or --save');
+    process.exit(1);
+  }
+
+  if (options.targets) {
+    const invalidPaths = [];
+    for (const target of options.targets) {
+      if (!validatePath(target)) {
+        invalidPaths.push(target);
+      }
+    }
+
+    if (invalidPaths.length > 0) {
+      console.error('Error: The following target paths do not exist or are not directories:');
+      invalidPaths.forEach(path => console.error(`  - ${path}`));
+      process.exit(1);
+    }
+  }
+
+  if (options.move && !options.saveDb && !options.resumeDb) {
+    console.error('Error: --move is only available with --save or --resume');
+    process.exit(1);
+  }
+
+  if (options.extensions && !options.saveDb && !options.resumeDb) {
+    console.error('Error: --extensions is only available with --save or --resume');
+    process.exit(1);
+  }
+  if (options.saveDb) {
+    const validation = validateNewFilePath(options.saveDb);
+    if (!validation.isValid) {
+      console.error(`Error: ${validation.error}`);
+      process.exit(1);
+    }
+  }
+}
+
+export {
+  validateOptions,
+  validatePath,
+  validateNewFilePath
+};