repo-cloak-cli 1.3.2 → 1.3.4

package/src/ui/prompts.js

@@ -5,53 +5,158 @@
 
 import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { existsSync } from 'fs';
+import { existsSync, mkdirSync } from 'fs';
 import { resolve, isAbsolute } from 'path';
+import { getSourcePaths, getDestPaths, addSourcePath, addDestPath } from '../core/path-cache.js';
+
+const ENTER_DIFFERENT = '__ENTER_DIFFERENT__';
+import { checkboxTreeSelectSingleDir } from './treeCheckboxSelector.js';
 
 /**
- * Prompt for source directory
+ * Build a list prompt with cached paths + "Enter a different path" option.
+ * Falls back to a plain input prompt when there are no cached paths.
+ * @param {object} opts
+ * @param {string}   opts.message        - Question shown to the user
+ * @param {string}   opts.inputMessage   - Follow-up message when they pick "Enter a different path"
+ * @param {string[]} opts.cachedPaths    - Decrypted cached paths to show
+ * @param {(path: string) => string|true} opts.validate - Validator for final resolved path
+ * @param {string}   [opts.defaultValue] - Default path
+ * @param {boolean}  [opts.allowNewSubfolder] - Ask to append a subfolder after selection
+ * @returns {Promise<string>} Resolved absolute path
  */
-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.';
+async function promptWithCache({ message, cachedPaths, validate, defaultValue, allowNewSubfolder }) {
+    // Build the displayed message — append a dim default hint if one is provided
+    const displayMessage = defaultValue
+        ? `${message} ${chalk.dim(`(press Enter to use current folder: ${defaultValue})`)}`
+        : message;
+
+    // With cached paths → show a quick-pick list with the question as its header
+    if (cachedPaths.length > 0) {
+        const { selected } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selected',
+                message: displayMessage,
+                choices: [
+                    ...cachedPaths.map(p => ({ name: p, value: p })),
+                    new inquirer.Separator(),
+                    { name: chalk.cyan('↵  Enter a different path'), value: ENTER_DIFFERENT }
+                ]
+            }
+        ]);
+
+        if (selected !== ENTER_DIFFERENT) {
+            let resolved = resolve(selected);
+
+            if (allowNewSubfolder) {
+                const { subfolder } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'subfolder',
+                    message: `Subfolder to create inside ${chalk.cyan(resolved)}? (press Enter to use current folder)`
+                }]);
+                if (subfolder.trim()) {
+                    resolved = resolve(resolved, subfolder.trim());
                 }
-                return true;
+            }
+
+            const result = validate(resolved);
+            if (result !== true) {
+                console.log(chalk.yellow(`   ⚠  ${result}`));
+            } else {
+                return resolved;
             }
         }
-    ]);
+    }
+
+    // No cache (or user chose "Enter a different path") → use hierarchical tree selector
+    console.log(chalk.dim('   (Use arrow keys to navigate, Space to expand/collapse, Enter to select)'));
+    let basePath = await checkboxTreeSelectSingleDir({
+        message: displayMessage,
+        root: process.cwd()
+    });
+
+    if (allowNewSubfolder) {
+        const { subfolder } = await inquirer.prompt([{
+            type: 'input',
+            name: 'subfolder',
+            message: `Subfolder to create inside ${chalk.cyan(basePath)}? (press Enter to use current folder)`
+        }]);
+        if (subfolder.trim()) {
+            basePath = resolve(basePath, subfolder.trim());
+        }
+    }
 
-    return resolve(sourcePath);
+    let finalPath = resolve(basePath);
+    // Loop until we get a path that passes validation
+    while (true) {
+        const result = validate(finalPath);
+        if (result === true) break;
+        console.log(chalk.yellow(`   ⚠  ${result}`));
+        
+        const { retry } = await inquirer.prompt([{
+            type: 'input',
+            name: 'retry',
+            message: 'Please type a valid absolute path:'
+        }]);
+        finalPath = resolve(retry.trim());
+    }
+
+    return finalPath;
 }
 
 /**
- * Prompt for destination directory
+ * Prompt for source directory (the repo to extract files from).
+ * Shows cached paths; validates that the directory exists.
+ * Saves the chosen path to the cache after selection.
  */
-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;
+export async function promptSourceDirectory() {
+    const cachedPaths = getSourcePaths();
+
+    const path = await promptWithCache({
+        message:      'Which repo do you want to extract files from?',
+        cachedPaths,
+        validate: (resolved) => {
+            if (!existsSync(resolved)) {
+                return `Directory not found: ${resolved}`;
             }
+            return true;
         }
-    ]);
+    });
 
-    return resolve(destPath);
+    addSourcePath(path);
+    return path;
 }
 
+/**
+ * Prompt for destination directory (where cloaked files will be saved).
+ * Shows cached paths; creates the folder automatically if it doesn't exist.
+ * Saves the chosen path to the cache after selection.
+ */
+export async function promptDestinationDirectory() {
+    const cachedPaths = getDestPaths();
+
+    const path = await promptWithCache({
+        message:      'Where should the cloaked (anonymized) files be saved?',
+        defaultValue: process.cwd(),
+        allowNewSubfolder: true,
+        cachedPaths,
+        validate: (resolved) => {
+            if (!resolved.trim()) return 'Please enter a destination path.';
+            return true; // Destination may not exist yet – we will create it
+        }
+    });
+
+    // Auto-create the destination if it doesn't exist
+    if (!existsSync(path)) {
+        mkdirSync(path, { recursive: true });
+        console.log(chalk.dim(`   Created directory: ${path}`));
+    }
+
+    addDestPath(path);
+    return path;
+}
+
+
 /**
  * Prompt for keyword replacements
  */
@@ -68,12 +173,12 @@ export async function promptKeywordReplacements() {
             {
                 type: 'input',
                 name: 'original',
-                message: 'Text to find (leave empty to finish):',
+                message: 'What do you want to replace? (leave empty to skip / finish):', 
             },
             {
                 type: 'input',
                 name: 'replacement',
-                message: 'Replace with:',
+                message: 'Replace it with:', 
                 when: (answers) => answers.original.trim() !== '',
                 validate: (input) => {
                     if (!input.trim()) {
@@ -139,7 +244,7 @@ export async function showSummaryAndConfirm(fileCount, destination, replacements
 
     console.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
 
-    return confirmAction('Proceed with extraction?');
+    return confirmAction('Everything looks good — go ahead?');
 }
 
 /**
@@ -150,7 +255,7 @@ export async function promptBackupFolder() {
         {
             type: 'input',
             name: 'folderPath',
-            message: 'Path to cloaked backup folder:',
+            message: 'Where is the cloaked folder you want to restore from?', 
             validate: (input) => {
                 const path = resolve(input);
                 if (!existsSync(path)) {

package/src/ui/treeCheckboxSelector.js

@@ -0,0 +1,253 @@
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+import checkbox from '@inquirer/checkbox';
+
+function buildTree(root, options) {
+  const { maxDepth, ignore } = options;
+  const nodes = new Map();
+  const checked = new Set();
+
+  function walk(currentPath, depth, parentId) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        if (ignore(fullPath, entry.name)) continue;
+
+        const id = fullPath;
+        const node = {
+          id,
+          name: entry.name,
+          fullPath,
+          parentId,
+          children: [],
+          isDirectory: entry.isDirectory(),
+        };
+        nodes.set(id, node);
+
+        if (parentId) {
+          const parent = nodes.get(parentId);
+          if (parent) parent.children.push(id);
+        }
+
+        if (entry.isDirectory()) {
+          walk(fullPath, depth + 1, id);
+        }
+      }
+    } catch (e) {
+      // ignore read errors
+    }
+  }
+
+  walk(root, 0, undefined);
+  return { nodes, checked };
+}
+
+function setSubtreeChecked(state, nodeId, checkedStatus) {
+  const queue = [nodeId];
+  while (queue.length) {
+    const id = queue.pop();
+    if (checkedStatus) state.checked.add(id);
+    else state.checked.delete(id);
+    const node = state.nodes.get(id);
+    if (node) queue.push(...node.children);
+  }
+}
+
+function recomputeParentFromChildren(state, nodeId) {
+  let current = state.nodes.get(nodeId);
+  while (current?.parentId) {
+    const parent = state.nodes.get(current.parentId);
+    if (!parent) break;
+    const allChildrenChecked = parent.children.length
+      ? parent.children.every((cid) => state.checked.has(cid))
+      : false;
+
+    if (allChildrenChecked) state.checked.add(parent.id);
+    else state.checked.delete(parent.id);
+
+    current = parent;
+  }
+}
+
+function applyExplicitNodeState(state, nodeId, targetState) {
+  setSubtreeChecked(state, nodeId, targetState);
+  recomputeParentFromChildren(state, nodeId);
+}
+
+function flattenNodesHierarchically(nodes) {
+  const roots = Array.from(nodes.values()).filter((n) => !n.parentId);
+  roots.sort((a, b) => a.name.localeCompare(b.name));
+
+  const flatList = [];
+
+  function visit(node, prefix, isLast) {
+    const connector = prefix ? (isLast ? '└─ ' : '├─ ') : '';
+    const icon = node.isDirectory ? '[d] ' : '    ';
+
+    flatList.push({
+      node,
+      displayName: `${prefix}${connector}${icon}${node.name}`
+    });
+
+    const childPrefix = prefix + (isLast ? '   ' : '|  ');
+    const children = node.children
+      .map((id) => nodes.get(id))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    children.forEach((child, index) => {
+      const last = index === children.length - 1;
+      visit(child, childPrefix, last);
+    });
+  }
+
+  roots.forEach((root, index) => {
+    const last = index === roots.length - 1;
+    visit(root, '', last);
+  });
+
+  return flatList;
+}
+
+function printSelectionSummary(root, state, hierarchicalNodes) {
+  const selectedFiles = hierarchicalNodes.filter(n => !n.node.isDirectory && state.checked.has(n.node.id));
+  if (selectedFiles.length === 0) {
+    console.log('\x1b[90m  (no files selected yet)\x1b[0m\n');
+  } else {
+    console.log(`\x1b[32m  ${selectedFiles.length} file(s) selected:\x1b[0m`);
+    const maxDisplay = 10;
+    selectedFiles.slice(0, maxDisplay).forEach(n => {
+      const rel = path.relative(root, n.node.id);
+      console.log(`    \x1b[32m+\x1b[0m ${rel}`);
+    });
+    if (selectedFiles.length > maxDisplay) {
+      console.log(`\x1b[90m    ... and ${selectedFiles.length - maxDisplay} more\x1b[0m`);
+    }
+    console.log('');
+  }
+}
+
+export async function checkboxTreeSelect(options = {}) {
+  const {
+    root = process.cwd(),
+    maxDepth = 5,
+    ignore = (fullPath, name) => name === 'node_modules' || name.startsWith('.git'),
+    message = 'Select files',
+    pageSize = 15,
+    precheck = [],
+  } = options;
+
+  const state = buildTree(root, { maxDepth, ignore });
+
+  if (precheck && precheck.length > 0) {
+    for (const p of precheck) {
+      if (state.nodes.has(p)) applyExplicitNodeState(state, p, true);
+    }
+  }
+
+  const hierarchicalNodes = flattenNodesHierarchically(state.nodes);
+  const allNodes = hierarchicalNodes.map(item => item.node);
+
+  if (hierarchicalNodes.length === 0) {
+    console.log(`No items found in ${root}`);
+    return [];
+  }
+
+  // Search loop: user types a query, sees filtered results, selects with space.
+  // Empty search + Enter = done.
+  while (true) {
+    console.clear();
+    console.log(`\nRoot: \x1b[1m${root}\x1b[0m`);
+    console.log('\x1b[90mType a filename to search. Space to select, Enter to confirm. Empty search + Enter to finish.\x1b[0m\n');
+    printSelectionSummary(root, state, hierarchicalNodes);
+
+    const { query } = await inquirer.prompt([{
+      type: 'input',
+      name: 'query',
+      message: `${message} — search:`,
+    }]);
+
+    const trimmed = query.trim().toLowerCase();
+
+    // Empty query = user is done selecting
+    if (!trimmed) break;
+
+    // Filter nodes whose relative path matches the query
+    const matched = hierarchicalNodes.filter(({ node }) => {
+      const rel = path.relative(root, node.id).toLowerCase();
+      return rel.includes(trimmed);
+    });
+
+    if (matched.length === 0) {
+      console.log(`\x1b[33m  No results for "${query}". Try a different term.\x1b[0m`);
+      await new Promise(r => setTimeout(r, 1200));
+      continue;
+    }
+
+    // Build choices for the checkbox prompt from search results
+    const choices = matched.map(({ node }) => {
+      const rel = path.relative(root, node.id);
+      const icon = node.isDirectory ? '[dir] ' : '';
+      return {
+        name: `${icon}${rel}`,
+        value: node.id,
+        checked: state.checked.has(node.id),
+      };
+    });
+
+    const prevChecked = new Set(state.checked);
+
+    let selected;
+    try {
+      selected = await checkbox({
+        message: `Results for "${query}" — Space to toggle, Enter to go back to search`,
+        choices,
+        pageSize,
+        loop: false,
+      });
+    } catch {
+      // User force-quit (ctrl+c) — treat as done
+      break;
+    }
+
+    // Apply changes: determine what was toggled from the matched set
+    const nextChecked = new Set(selected);
+    for (const { node } of matched) {
+      const was = prevChecked.has(node.id);
+      const now = nextChecked.has(node.id);
+      if (was !== now) {
+        applyExplicitNodeState(state, node.id, now);
+      }
+    }
+  }
+
+  return Array.from(state.checked);
+}
+
+export async function checkboxTreeSelectFilesOnly(options = {}) {
+  const paths = await checkboxTreeSelect(options);
+  return paths.filter((p) => {
+    try {
+      return fs.statSync(p).isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+
+export async function checkboxTreeSelectSingleDir(options = {}) {
+  while (true) {
+    const paths = await checkboxTreeSelect({ ...options, message: options.message + ' (Select MAXIMUM ONE directory)' });
+    const dirs = paths.filter(p => {
+      try { return fs.statSync(p).isDirectory(); } catch { return false; }
+    });
+    if (dirs.length > 1) {
+      console.log('\nPlease select ONLY ONE directory.\n');
+      continue;
+    }
+    return dirs[0] || '';
+  }
+}

package/test-tree.js

@@ -0,0 +1,2 @@
+import { checkboxTreeSelect } from './src/ui/treeCheckboxSelector.js';
+checkboxTreeSelect({ root: process.cwd(), maxDepth: 1 }).then(res => console.log(res));

package/tests/anonymizer.test.js

@@ -9,37 +9,37 @@ describe('Anonymizer', () => {
     describe('createAnonymizer', () => {
         it('should replace exact matches', () => {
             const anonymizer = createAnonymizer([
-                { original: 'Cuviva', replacement: 'ABCCompany' }
+                { original: 'Microsoft', replacement: 'ABCCompany' }
             ]);
 
             // Title case input -> Title case output (first letter upper, rest lower)
-            expect(anonymizer('Hello Cuviva world')).toBe('Hello Abccompany world');
+            expect(anonymizer('Hello Microsoft world')).toBe('Hello Abccompany world');
         });
 
         it('should handle all uppercase', () => {
             const anonymizer = createAnonymizer([
-                { original: 'Cuviva', replacement: 'ABCCompany' }
+                { original: 'Microsoft', replacement: 'ABCCompany' }
             ]);
 
-            expect(anonymizer('CUVIVA is great')).toBe('ABCCOMPANY is great');
+            expect(anonymizer('MICROSOFT is great')).toBe('ABCCOMPANY is great');
         });
 
         it('should handle all lowercase', () => {
             const anonymizer = createAnonymizer([
-                { original: 'Cuviva', replacement: 'ABCCompany' }
+                { original: 'Microsoft', replacement: 'ABCCompany' }
             ]);
 
-            expect(anonymizer('cuviva is lower')).toBe('abccompany is lower');
+            expect(anonymizer('microsoft is lower')).toBe('abccompany is lower');
         });
 
         it('should handle multiple replacements', () => {
             const anonymizer = createAnonymizer([
-                { original: 'Cuviva', replacement: 'ABCCompany' },
+                { original: 'Microsoft', replacement: 'ABCCompany' },
                 { original: 'Frontend', replacement: 'Client' }
             ]);
 
             // Both are Title case -> first upper + rest lower
-            expect(anonymizer('Cuviva Frontend API')).toBe('Abccompany Client API');
+            expect(anonymizer('Microsoft Frontend API')).toBe('Abccompany Client API');
         });
 
         it('should handle empty replacements', () => {
@@ -65,45 +65,45 @@ describe('Anonymizer', () => {
     describe('createDeanonymizer', () => {
         it('should reverse the anonymization', () => {
             const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' }
+                { original: 'Microsoft', 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');
+            // ABCCompany (Title case) -> Microsoft (Title case: first upper + rest lower)
+            expect(deanonymizer('Hello ABCCompany world')).toBe('Hello Microsoft world');
         });
 
         it('should handle multiple replacements in reverse', () => {
             const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' },
+                { original: 'Microsoft', replacement: 'ABCCompany' },
                 { original: 'API', replacement: 'Service' }
             ];
 
             const deanonymizer = createDeanonymizer(replacements);
 
             // Title case -> Title case for both
-            expect(deanonymizer('ABCCompany Service')).toBe('Cuviva Api');
+            expect(deanonymizer('ABCCompany Service')).toBe('Microsoft Api');
         });
 
         it('should handle uppercase in reverse', () => {
             const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' }
+                { original: 'Microsoft', replacement: 'ABCCompany' }
             ];
 
             const deanonymizer = createDeanonymizer(replacements);
 
-            expect(deanonymizer('ABCCOMPANY')).toBe('CUVIVA');
+            expect(deanonymizer('ABCCOMPANY')).toBe('MICROSOFT');
         });
 
         it('should handle lowercase in reverse', () => {
             const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' }
+                { original: 'Microsoft', replacement: 'ABCCompany' }
             ];
 
             const deanonymizer = createDeanonymizer(replacements);
 
-            expect(deanonymizer('abccompany')).toBe('cuviva');
+            expect(deanonymizer('abccompany')).toBe('microsoft');
         });
     });
 });

package/tests/copier.test.js

@@ -55,9 +55,9 @@ describe('Copier Module', () => {
             const sourceFile = join(sourceDir, 'code.js');
             const destFile = join(destDir, 'code.js');
 
-            writeFileSync(sourceFile, 'const company = "Cuviva";');
+            writeFileSync(sourceFile, 'const company = "Microsoft";');
 
-            const transform = (content) => content.replace(/Cuviva/g, 'ABCCompany');
+            const transform = (content) => content.replace(/Microsoft/g, 'ABCCompany');
             const result = copyFileWithTransform(sourceFile, destFile, transform);
 
             expect(result.transformed).toBe(true);
@@ -70,7 +70,7 @@ describe('Copier Module', () => {
 
             writeFileSync(sourceFile, 'const x = 1;');
 
-            const transform = (content) => content.replace(/Cuviva/g, 'ABCCompany');
+            const transform = (content) => content.replace(/Microsoft/g, 'ABCCompany');
             const result = copyFileWithTransform(sourceFile, destFile, transform);
 
             expect(result.transformed).toBe(false);

package/tests/crypto.test.js

@@ -65,7 +65,7 @@ describe('Crypto Module', () => {
     describe('encryptReplacements/decryptReplacements', () => {
         it('should encrypt only the original field', () => {
             const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' },
+                { original: 'Microsoft', replacement: 'ABCCompany' },
                 { original: 'Secret', replacement: 'Public' }
             ];
 
@@ -82,13 +82,13 @@ describe('Crypto Module', () => {
 
         it('should decrypt back to original', () => {
             const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' }
+                { original: 'Microsoft', replacement: 'ABCCompany' }
             ];
 
             const encrypted = encryptReplacements(replacements, testSecret);
             const decrypted = decryptReplacements(encrypted, testSecret);
 
-            expect(decrypted[0].original).toBe('Cuviva');
+            expect(decrypted[0].original).toBe('Microsoft');
             expect(decrypted[0].replacement).toBe('ABCCompany');
         });