repo-cloak-cli 1.2.4 → 1.3.2

package/src/ui/prompts.js

@@ -1,165 +1,165 @@
-/**
- * User Prompts
- * Handles all user input prompts
- */
-
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import { existsSync } from 'fs';
-import { resolve, isAbsolute } from 'path';
-
-/**
- * Prompt for source directory
- */
-export async function promptSourceDirectory(defaultPath = process.cwd()) {
-    const { sourcePath } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'sourcePath',
-            message: 'Source directory:',
-            default: defaultPath,
-            validate: (input) => {
-                const path = resolve(input);
-                if (!existsSync(path)) {
-                    return 'Directory does not exist. Please enter a valid path.';
-                }
-                return true;
-            }
-        }
-    ]);
-
-    return resolve(sourcePath);
-}
-
-/**
- * Prompt for destination directory
- */
-export async function promptDestinationDirectory() {
-    const { destPath } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'destPath',
-            message: 'Destination directory (will be created if not exists):',
-            validate: (input) => {
-                if (!input.trim()) {
-                    return 'Please enter a destination path.';
-                }
-                return true;
-            }
-        }
-    ]);
-
-    return resolve(destPath);
-}
-
-/**
- * Prompt for keyword replacements
- */
-export async function promptKeywordReplacements() {
-    const replacements = [];
-
-    console.log(chalk.cyan('\n🔄 Keyword Replacements'));
-    console.log(chalk.dim('   Replace sensitive information with anonymous values.\n'));
-
-    let addMore = true;
-
-    while (addMore) {
-        const { original, replacement } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'original',
-                message: 'Text to find (leave empty to finish):',
-            },
-            {
-                type: 'input',
-                name: 'replacement',
-                message: 'Replace with:',
-                when: (answers) => answers.original.trim() !== '',
-                validate: (input) => {
-                    if (!input.trim()) {
-                        return 'Please enter a replacement value.';
-                    }
-                    return true;
-                }
-            }
-        ]);
-
-        if (original.trim() === '') {
-            addMore = false;
-        } else {
-            replacements.push({
-                original: original.trim(),
-                replacement: replacement.trim()
-            });
-
-            console.log(chalk.green(`   ✓ "${original}" → "${replacement}"`));
-        }
-    }
-
-    if (replacements.length === 0) {
-        console.log(chalk.yellow('   No replacements configured. Files will be copied as-is.'));
-    }
-
-    return replacements;
-}
-
-/**
- * Confirm before proceeding
- */
-export async function confirmAction(message) {
-    const { confirmed } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'confirmed',
-            message,
-            default: true
-        }
-    ]);
-
-    return confirmed;
-}
-
-/**
- * Show summary of selections
- */
-export async function showSummaryAndConfirm(fileCount, destination, replacements) {
-    console.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
-    console.log(chalk.white.bold('📋 Summary\n'));
-    console.log(chalk.white(`   📂 Files to copy: ${chalk.yellow.bold(fileCount)}`));
-    console.log(chalk.white(`   📍 Destination: ${chalk.yellow.bold(destination)}`));
-
-    if (replacements.length > 0) {
-        console.log(chalk.white(`   🔄 Replacements: ${chalk.yellow.bold(replacements.length)}`));
-        replacements.forEach(r => {
-            console.log(chalk.dim(`      "${r.original}" → "${r.replacement}"`));
-        });
-    } else {
-        console.log(chalk.white(`   🔄 Replacements: ${chalk.dim('None')}`));
-    }
-
-    console.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
-
-    return confirmAction('Proceed with extraction?');
-}
-
-/**
- * Prompt for selecting a backup folder (for push command)
- */
-export async function promptBackupFolder() {
-    const { folderPath } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'folderPath',
-            message: 'Path to cloaked backup folder:',
-            validate: (input) => {
-                const path = resolve(input);
-                if (!existsSync(path)) {
-                    return 'Folder does not exist. Please enter a valid path.';
-                }
-                return true;
-            }
-        }
-    ]);
-
-    return resolve(folderPath);
-}
+/**
+ * User Prompts
+ * Handles all user input prompts
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { resolve, isAbsolute } from 'path';
+
+/**
+ * Prompt for source directory
+ */
+export async function promptSourceDirectory(defaultPath = process.cwd()) {
+    const { sourcePath } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'sourcePath',
+            message: 'Source directory:',
+            default: defaultPath,
+            validate: (input) => {
+                const path = resolve(input);
+                if (!existsSync(path)) {
+                    return 'Directory does not exist. Please enter a valid path.';
+                }
+                return true;
+            }
+        }
+    ]);
+
+    return resolve(sourcePath);
+}
+
+/**
+ * Prompt for destination directory
+ */
+export async function promptDestinationDirectory() {
+    const { destPath } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'destPath',
+            message: 'Destination directory (will be created if not exists):',
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'Please enter a destination path.';
+                }
+                return true;
+            }
+        }
+    ]);
+
+    return resolve(destPath);
+}
+
+/**
+ * Prompt for keyword replacements
+ */
+export async function promptKeywordReplacements() {
+    const replacements = [];
+
+    console.log(chalk.cyan('\n🔄 Keyword Replacements'));
+    console.log(chalk.dim('   Replace sensitive information with anonymous values.\n'));
+
+    let addMore = true;
+
+    while (addMore) {
+        const { original, replacement } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'original',
+                message: 'Text to find (leave empty to finish):',
+            },
+            {
+                type: 'input',
+                name: 'replacement',
+                message: 'Replace with:',
+                when: (answers) => answers.original.trim() !== '',
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return 'Please enter a replacement value.';
+                    }
+                    return true;
+                }
+            }
+        ]);
+
+        if (original.trim() === '') {
+            addMore = false;
+        } else {
+            replacements.push({
+                original: original.trim(),
+                replacement: replacement.trim()
+            });
+
+            console.log(chalk.green(`   ✓ "${original}" → "${replacement}"`));
+        }
+    }
+
+    if (replacements.length === 0) {
+        console.log(chalk.yellow('   No replacements configured. Files will be copied as-is.'));
+    }
+
+    return replacements;
+}
+
+/**
+ * Confirm before proceeding
+ */
+export async function confirmAction(message) {
+    const { confirmed } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirmed',
+            message,
+            default: true
+        }
+    ]);
+
+    return confirmed;
+}
+
+/**
+ * Show summary of selections
+ */
+export async function showSummaryAndConfirm(fileCount, destination, replacements) {
+    console.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+    console.log(chalk.white.bold('📋 Summary\n'));
+    console.log(chalk.white(`   📂 Files to copy: ${chalk.yellow.bold(fileCount)}`));
+    console.log(chalk.white(`   📍 Destination: ${chalk.yellow.bold(destination)}`));
+
+    if (replacements.length > 0) {
+        console.log(chalk.white(`   🔄 Replacements: ${chalk.yellow.bold(replacements.length)}`));
+        replacements.forEach(r => {
+            console.log(chalk.dim(`      "${r.original}" → "${r.replacement}"`));
+        });
+    } else {
+        console.log(chalk.white(`   🔄 Replacements: ${chalk.dim('None')}`));
+    }
+
+    console.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+    return confirmAction('Proceed with extraction?');
+}
+
+/**
+ * Prompt for selecting a backup folder (for push command)
+ */
+export async function promptBackupFolder() {
+    const { folderPath } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'folderPath',
+            message: 'Path to cloaked backup folder:',
+            validate: (input) => {
+                const path = resolve(input);
+                if (!existsSync(path)) {
+                    return 'Folder does not exist. Please enter a valid path.';
+                }
+                return true;
+            }
+        }
+    ]);
+
+    return resolve(folderPath);
+}

package/tests/anonymizer.test.js

@@ -1,127 +1,127 @@
-/**
- * Anonymizer Tests
- */
-
-import { describe, it, expect } from 'vitest';
-import { createAnonymizer, createDeanonymizer } from '../src/core/anonymizer.js';
-
-describe('Anonymizer', () => {
-    describe('createAnonymizer', () => {
-        it('should replace exact matches', () => {
-            const anonymizer = createAnonymizer([
-                { original: 'Cuviva', replacement: 'ABCCompany' }
-            ]);
-
-            // Title case input -> Title case output (first letter upper, rest lower)
-            expect(anonymizer('Hello Cuviva world')).toBe('Hello Abccompany world');
-        });
-
-        it('should handle all uppercase', () => {
-            const anonymizer = createAnonymizer([
-                { original: 'Cuviva', replacement: 'ABCCompany' }
-            ]);
-
-            expect(anonymizer('CUVIVA is great')).toBe('ABCCOMPANY is great');
-        });
-
-        it('should handle all lowercase', () => {
-            const anonymizer = createAnonymizer([
-                { original: 'Cuviva', replacement: 'ABCCompany' }
-            ]);
-
-            expect(anonymizer('cuviva is lower')).toBe('abccompany is lower');
-        });
-
-        it('should handle multiple replacements', () => {
-            const anonymizer = createAnonymizer([
-                { original: 'Cuviva', replacement: 'ABCCompany' },
-                { original: 'Frontend', replacement: 'Client' }
-            ]);
-
-            // Both are Title case -> first upper + rest lower
-            expect(anonymizer('Cuviva Frontend API')).toBe('Abccompany Client API');
-        });
-
-        it('should handle empty replacements', () => {
-            const anonymizer = createAnonymizer([]);
-            expect(anonymizer('Hello world')).toBe('Hello world');
-        });
-
-        it('should handle special regex characters in original', () => {
-            const anonymizer = createAnonymizer([
-                { original: 'test.value', replacement: 'replaced' }
-            ]);
-
-            // Title case preservation
-            expect(anonymizer('This is Test.value here')).toBe('This is Replaced here');
-        });
-
-        it('should handle null or undefined replacements', () => {
-            const anonymizer = createAnonymizer(null);
-            expect(anonymizer('Hello world')).toBe('Hello world');
-        });
-    });
-
-    describe('createDeanonymizer', () => {
-        it('should reverse the anonymization', () => {
-            const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' }
-            ];
-
-            const deanonymizer = createDeanonymizer(replacements);
-
-            // ABCCompany (Title case) -> Cuviva (Title case: first upper + rest lower)
-            expect(deanonymizer('Hello ABCCompany world')).toBe('Hello Cuviva world');
-        });
-
-        it('should handle multiple replacements in reverse', () => {
-            const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' },
-                { original: 'API', replacement: 'Service' }
-            ];
-
-            const deanonymizer = createDeanonymizer(replacements);
-
-            // Title case -> Title case for both
-            expect(deanonymizer('ABCCompany Service')).toBe('Cuviva Api');
-        });
-
-        it('should handle uppercase in reverse', () => {
-            const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' }
-            ];
-
-            const deanonymizer = createDeanonymizer(replacements);
-
-            expect(deanonymizer('ABCCOMPANY')).toBe('CUVIVA');
-        });
-
-        it('should handle lowercase in reverse', () => {
-            const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' }
-            ];
-
-            const deanonymizer = createDeanonymizer(replacements);
-
-            expect(deanonymizer('abccompany')).toBe('cuviva');
-        });
-    });
-});
-
-describe('Case transformation', () => {
-    it('should preserve all uppercase', () => {
-        const anonymizer = createAnonymizer([
-            { original: 'SECRET', replacement: 'PUBLIC' }
-        ]);
-
-        expect(anonymizer('This is SECRET data')).toBe('This is PUBLIC data');
-    });
-
-    it('should preserve all lowercase', () => {
-        const anonymizer = createAnonymizer([
-            { original: 'secret', replacement: 'public' }
-        ]);
-
-        expect(anonymizer('this is secret data')).toBe('this is public data');
-    });
-});
+/**
+ * Anonymizer Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createAnonymizer, createDeanonymizer } from '../src/core/anonymizer.js';
+
+describe('Anonymizer', () => {
+    describe('createAnonymizer', () => {
+        it('should replace exact matches', () => {
+            const anonymizer = createAnonymizer([
+                { original: 'Cuviva', replacement: 'ABCCompany' }
+            ]);
+
+            // Title case input -> Title case output (first letter upper, rest lower)
+            expect(anonymizer('Hello Cuviva world')).toBe('Hello Abccompany world');
+        });
+
+        it('should handle all uppercase', () => {
+            const anonymizer = createAnonymizer([
+                { original: 'Cuviva', replacement: 'ABCCompany' }
+            ]);
+
+            expect(anonymizer('CUVIVA is great')).toBe('ABCCOMPANY is great');
+        });
+
+        it('should handle all lowercase', () => {
+            const anonymizer = createAnonymizer([
+                { original: 'Cuviva', replacement: 'ABCCompany' }
+            ]);
+
+            expect(anonymizer('cuviva is lower')).toBe('abccompany is lower');
+        });
+
+        it('should handle multiple replacements', () => {
+            const anonymizer = createAnonymizer([
+                { original: 'Cuviva', replacement: 'ABCCompany' },
+                { original: 'Frontend', replacement: 'Client' }
+            ]);
+
+            // Both are Title case -> first upper + rest lower
+            expect(anonymizer('Cuviva Frontend API')).toBe('Abccompany Client API');
+        });
+
+        it('should handle empty replacements', () => {
+            const anonymizer = createAnonymizer([]);
+            expect(anonymizer('Hello world')).toBe('Hello world');
+        });
+
+        it('should handle special regex characters in original', () => {
+            const anonymizer = createAnonymizer([
+                { original: 'test.value', replacement: 'replaced' }
+            ]);
+
+            // Title case preservation
+            expect(anonymizer('This is Test.value here')).toBe('This is Replaced here');
+        });
+
+        it('should handle null or undefined replacements', () => {
+            const anonymizer = createAnonymizer(null);
+            expect(anonymizer('Hello world')).toBe('Hello world');
+        });
+    });
+
+    describe('createDeanonymizer', () => {
+        it('should reverse the anonymization', () => {
+            const replacements = [
+                { original: 'Cuviva', replacement: 'ABCCompany' }
+            ];
+
+            const deanonymizer = createDeanonymizer(replacements);
+
+            // ABCCompany (Title case) -> Cuviva (Title case: first upper + rest lower)
+            expect(deanonymizer('Hello ABCCompany world')).toBe('Hello Cuviva world');
+        });
+
+        it('should handle multiple replacements in reverse', () => {
+            const replacements = [
+                { original: 'Cuviva', replacement: 'ABCCompany' },
+                { original: 'API', replacement: 'Service' }
+            ];
+
+            const deanonymizer = createDeanonymizer(replacements);
+
+            // Title case -> Title case for both
+            expect(deanonymizer('ABCCompany Service')).toBe('Cuviva Api');
+        });
+
+        it('should handle uppercase in reverse', () => {
+            const replacements = [
+                { original: 'Cuviva', replacement: 'ABCCompany' }
+            ];
+
+            const deanonymizer = createDeanonymizer(replacements);
+
+            expect(deanonymizer('ABCCOMPANY')).toBe('CUVIVA');
+        });
+
+        it('should handle lowercase in reverse', () => {
+            const replacements = [
+                { original: 'Cuviva', replacement: 'ABCCompany' }
+            ];
+
+            const deanonymizer = createDeanonymizer(replacements);
+
+            expect(deanonymizer('abccompany')).toBe('cuviva');
+        });
+    });
+});
+
+describe('Case transformation', () => {
+    it('should preserve all uppercase', () => {
+        const anonymizer = createAnonymizer([
+            { original: 'SECRET', replacement: 'PUBLIC' }
+        ]);
+
+        expect(anonymizer('This is SECRET data')).toBe('This is PUBLIC data');
+    });
+
+    it('should preserve all lowercase', () => {
+        const anonymizer = createAnonymizer([
+            { original: 'secret', replacement: 'public' }
+        ]);
+
+        expect(anonymizer('this is secret data')).toBe('this is public data');
+    });
+});