repo-cloak-cli 1.2.4 → 1.3.2

package/src/core/anonymizer.js

@@ -1,128 +1,128 @@
-/**
- * Anonymizer
- * Handles keyword replacement for anonymizing content
- */
-
-/**
- * Create a replacement function for a list of replacements
- * @param {Array<{original: string, replacement: string}>} replacements
- * @param {Object} options
- * @returns {Function} Transform function
- */
-export function createAnonymizer(replacements, options = {}) {
-    const { caseSensitive = false } = options;
-
-    if (!replacements || replacements.length === 0) {
-        return (content) => content;
-    }
-
-    return (content) => {
-        let result = content;
-
-        for (const { original, replacement } of replacements) {
-            if (caseSensitive) {
-                // Case-sensitive replacement
-                result = result.split(original).join(replacement);
-            } else {
-                // Case-insensitive replacement using regex
-                const regex = new RegExp(escapeRegex(original), 'gi');
-                result = result.replace(regex, (match) => {
-                    // Preserve case pattern
-                    return matchCase(match, replacement);
-                });
-            }
-        }
-
-        return result;
-    };
-}
-
-/**
- * Create reverse anonymizer (for push operation)
- * @param {Array<{original: string, replacement: string}>} replacements
- * @returns {Function} Transform function
- */
-export function createDeanonymizer(replacements, options = {}) {
-    const { caseSensitive = false } = options;
-
-    if (!replacements || replacements.length === 0) {
-        return (content) => content;
-    }
-
-    // Reverse the replacements
-    const reversed = replacements.map(r => ({
-        original: r.replacement,
-        replacement: r.original
-    }));
-
-    return createAnonymizer(reversed, options);
-}
-
-/**
- * Escape special regex characters
- */
-function escapeRegex(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Match the case pattern of the original to the replacement
- */
-function matchCase(original, replacement) {
-    // If original is all uppercase, make replacement uppercase
-    if (original === original.toUpperCase()) {
-        return replacement.toUpperCase();
-    }
-
-    // If original is all lowercase, make replacement lowercase
-    if (original === original.toLowerCase()) {
-        return replacement.toLowerCase();
-    }
-
-    // If original is Title Case, make replacement Title Case
-    if (original[0] === original[0].toUpperCase()) {
-        return replacement.charAt(0).toUpperCase() + replacement.slice(1).toLowerCase();
-    }
-
-    // Default: return replacement as-is
-    return replacement;
-}
-
-/**
- * Apply replacements to a file path (for renaming files/folders)
- */
-export function anonymizePath(filePath, replacements) {
-    if (!replacements || replacements.length === 0) {
-        return filePath;
-    }
-
-    let result = filePath;
-
-    for (const { original, replacement } of replacements) {
-        const regex = new RegExp(escapeRegex(original), 'gi');
-        result = result.replace(regex, replacement);
-    }
-
-    return result;
-}
-
-/**
- * Count replacements in content
- */
-export function countReplacements(content, replacements) {
-    if (!replacements || replacements.length === 0) {
-        return 0;
-    }
-
-    let count = 0;
-
-    for (const { original } of replacements) {
-        const regex = new RegExp(escapeRegex(original), 'gi');
-        const matches = content.match(regex);
-        if (matches) {
-            count += matches.length;
-        }
-    }
-
-    return count;
-}
+/**
+ * Anonymizer
+ * Handles keyword replacement for anonymizing content
+ */
+
+/**
+ * Create a replacement function for a list of replacements
+ * @param {Array<{original: string, replacement: string}>} replacements
+ * @param {Object} options
+ * @returns {Function} Transform function
+ */
+export function createAnonymizer(replacements, options = {}) {
+    const { caseSensitive = false } = options;
+
+    if (!replacements || replacements.length === 0) {
+        return (content) => content;
+    }
+
+    return (content) => {
+        let result = content;
+
+        for (const { original, replacement } of replacements) {
+            if (caseSensitive) {
+                // Case-sensitive replacement
+                result = result.split(original).join(replacement);
+            } else {
+                // Case-insensitive replacement using regex
+                const regex = new RegExp(escapeRegex(original), 'gi');
+                result = result.replace(regex, (match) => {
+                    // Preserve case pattern
+                    return matchCase(match, replacement);
+                });
+            }
+        }
+
+        return result;
+    };
+}
+
+/**
+ * Create reverse anonymizer (for push operation)
+ * @param {Array<{original: string, replacement: string}>} replacements
+ * @returns {Function} Transform function
+ */
+export function createDeanonymizer(replacements, options = {}) {
+    const { caseSensitive = false } = options;
+
+    if (!replacements || replacements.length === 0) {
+        return (content) => content;
+    }
+
+    // Reverse the replacements
+    const reversed = replacements.map(r => ({
+        original: r.replacement,
+        replacement: r.original
+    }));
+
+    return createAnonymizer(reversed, options);
+}
+
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Match the case pattern of the original to the replacement
+ */
+function matchCase(original, replacement) {
+    // If original is all uppercase, make replacement uppercase
+    if (original === original.toUpperCase()) {
+        return replacement.toUpperCase();
+    }
+
+    // If original is all lowercase, make replacement lowercase
+    if (original === original.toLowerCase()) {
+        return replacement.toLowerCase();
+    }
+
+    // If original is Title Case, make replacement Title Case
+    if (original[0] === original[0].toUpperCase()) {
+        return replacement.charAt(0).toUpperCase() + replacement.slice(1).toLowerCase();
+    }
+
+    // Default: return replacement as-is
+    return replacement;
+}
+
+/**
+ * Apply replacements to a file path (for renaming files/folders)
+ */
+export function anonymizePath(filePath, replacements) {
+    if (!replacements || replacements.length === 0) {
+        return filePath;
+    }
+
+    let result = filePath;
+
+    for (const { original, replacement } of replacements) {
+        const regex = new RegExp(escapeRegex(original), 'gi');
+        result = result.replace(regex, replacement);
+    }
+
+    return result;
+}
+
+/**
+ * Count replacements in content
+ */
+export function countReplacements(content, replacements) {
+    if (!replacements || replacements.length === 0) {
+        return 0;
+    }
+
+    let count = 0;
+
+    for (const { original } of replacements) {
+        const regex = new RegExp(escapeRegex(original), 'gi');
+        const matches = content.match(regex);
+        if (matches) {
+            count += matches.length;
+        }
+    }
+
+    return count;
+}

package/src/core/copier.js

@@ -1,139 +1,139 @@
-/**
- * File Copier
- * Copies files while preserving directory structure
- * Now also anonymizes folder/file names!
- */
-
-import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join, relative, basename } from 'path';
-import { isBinaryFile } from './scanner.js';
-
-/**
- * Apply replacements to a path (file/folder names)
- */
-function anonymizePath(relativePath, replacements) {
-    if (!replacements || replacements.length === 0) {
-        return relativePath;
-    }
-
-    let result = relativePath;
-    for (const { original, replacement } of replacements) {
-        // Case-insensitive replacement
-        const regex = new RegExp(escapeRegex(original), 'gi');
-        result = result.replace(regex, (match) => matchCase(match, replacement));
-    }
-    return result;
-}
-
-/**
- * Escape special regex characters
- */
-function escapeRegex(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Match case pattern
- */
-function matchCase(original, replacement) {
-    if (original === original.toUpperCase()) {
-        return replacement.toUpperCase();
-    }
-    if (original === original.toLowerCase()) {
-        return replacement.toLowerCase();
-    }
-    if (original[0] === original[0].toUpperCase()) {
-        return replacement.charAt(0).toUpperCase() + replacement.slice(1);
-    }
-    return replacement;
-}
-
-/**
- * Copy a single file, creating directories as needed
- */
-export function copyFile(sourcePath, destPath) {
-    const destDir = dirname(destPath);
-    mkdirSync(destDir, { recursive: true });
-    copyFileSync(sourcePath, destPath);
-}
-
-/**
- * Copy a file with content transformation
- */
-export function copyFileWithTransform(sourcePath, destPath, transformFn) {
-    const destDir = dirname(destPath);
-    mkdirSync(destDir, { recursive: true });
-
-    if (isBinaryFile(sourcePath)) {
-        copyFileSync(sourcePath, destPath);
-        return { transformed: false };
-    }
-
-    try {
-        let content = readFileSync(sourcePath, 'utf-8');
-        const originalContent = content;
-        content = transformFn(content);
-        writeFileSync(destPath, content, 'utf-8');
-        return {
-            transformed: content !== originalContent,
-            originalLength: originalContent.length,
-            newLength: content.length
-        };
-    } catch (error) {
-        copyFileSync(sourcePath, destPath);
-        return { transformed: false, error: error.message };
-    }
-}
-
-/**
- * Copy multiple files with progress callback
- * Now also renames folders/files based on replacements!
- */
-export async function copyFiles(files, sourceBase, destBase, transformFn, onProgress, replacements = []) {
-    const results = {
-        total: files.length,
-        copied: 0,
-        transformed: 0,
-        pathsRenamed: 0,
-        errors: []
-    };
-
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        const originalRelativePath = typeof file === 'string'
-            ? relative(sourceBase, file)
-            : file.relativePath;
-        const sourcePath = typeof file === 'string' ? file : file.absolutePath;
-
-        // Anonymize the path (folder and file names)
-        const anonymizedPath = anonymizePath(originalRelativePath, replacements);
-        const destPath = join(destBase, anonymizedPath);
-
-        if (anonymizedPath !== originalRelativePath) {
-            results.pathsRenamed++;
-        }
-
-        try {
-            if (transformFn) {
-                const result = copyFileWithTransform(sourcePath, destPath, transformFn);
-                if (result.transformed) {
-                    results.transformed++;
-                }
-            } else {
-                copyFile(sourcePath, destPath);
-            }
-            results.copied++;
-        } catch (error) {
-            results.errors.push({
-                file: originalRelativePath,
-                error: error.message
-            });
-        }
-
-        if (onProgress) {
-            onProgress(i + 1, files.length, anonymizedPath);
-        }
-    }
-
-    return results;
-}
+/**
+ * File Copier
+ * Copies files while preserving directory structure
+ * Now also anonymizes folder/file names!
+ */
+
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, relative, basename } from 'path';
+import { isBinaryFile } from './scanner.js';
+
+/**
+ * Apply replacements to a path (file/folder names)
+ */
+function anonymizePath(relativePath, replacements) {
+    if (!replacements || replacements.length === 0) {
+        return relativePath;
+    }
+
+    let result = relativePath;
+    for (const { original, replacement } of replacements) {
+        // Case-insensitive replacement
+        const regex = new RegExp(escapeRegex(original), 'gi');
+        result = result.replace(regex, (match) => matchCase(match, replacement));
+    }
+    return result;
+}
+
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Match case pattern
+ */
+function matchCase(original, replacement) {
+    if (original === original.toUpperCase()) {
+        return replacement.toUpperCase();
+    }
+    if (original === original.toLowerCase()) {
+        return replacement.toLowerCase();
+    }
+    if (original[0] === original[0].toUpperCase()) {
+        return replacement.charAt(0).toUpperCase() + replacement.slice(1);
+    }
+    return replacement;
+}
+
+/**
+ * Copy a single file, creating directories as needed
+ */
+export function copyFile(sourcePath, destPath) {
+    const destDir = dirname(destPath);
+    mkdirSync(destDir, { recursive: true });
+    copyFileSync(sourcePath, destPath);
+}
+
+/**
+ * Copy a file with content transformation
+ */
+export function copyFileWithTransform(sourcePath, destPath, transformFn) {
+    const destDir = dirname(destPath);
+    mkdirSync(destDir, { recursive: true });
+
+    if (isBinaryFile(sourcePath)) {
+        copyFileSync(sourcePath, destPath);
+        return { transformed: false };
+    }
+
+    try {
+        let content = readFileSync(sourcePath, 'utf-8');
+        const originalContent = content;
+        content = transformFn(content);
+        writeFileSync(destPath, content, 'utf-8');
+        return {
+            transformed: content !== originalContent,
+            originalLength: originalContent.length,
+            newLength: content.length
+        };
+    } catch (error) {
+        copyFileSync(sourcePath, destPath);
+        return { transformed: false, error: error.message };
+    }
+}
+
+/**
+ * Copy multiple files with progress callback
+ * Now also renames folders/files based on replacements!
+ */
+export async function copyFiles(files, sourceBase, destBase, transformFn, onProgress, replacements = []) {
+    const results = {
+        total: files.length,
+        copied: 0,
+        transformed: 0,
+        pathsRenamed: 0,
+        errors: []
+    };
+
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const originalRelativePath = typeof file === 'string'
+            ? relative(sourceBase, file)
+            : file.relativePath;
+        const sourcePath = typeof file === 'string' ? file : file.absolutePath;
+
+        // Anonymize the path (folder and file names)
+        const anonymizedPath = anonymizePath(originalRelativePath, replacements);
+        const destPath = join(destBase, anonymizedPath);
+
+        if (anonymizedPath !== originalRelativePath) {
+            results.pathsRenamed++;
+        }
+
+        try {
+            if (transformFn) {
+                const result = copyFileWithTransform(sourcePath, destPath, transformFn);
+                if (result.transformed) {
+                    results.transformed++;
+                }
+            } else {
+                copyFile(sourcePath, destPath);
+            }
+            results.copied++;
+        } catch (error) {
+            results.errors.push({
+                file: originalRelativePath,
+                error: error.message
+            });
+        }
+
+        if (onProgress) {
+            onProgress(i + 1, files.length, anonymizedPath);
+        }
+    }
+
+    return results;
+}