repo-cloak-cli 1.3.2 → 1.3.4

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "repo-cloak-cli",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "🎭 Selectively extract and anonymize files from repositories. Perfect for sharing code with AI agents without exposing proprietary details.",
   "main": "src/index.js",
   "type": "module",
   "bin": {
-    "repo-cloak": "./bin/repo-cloak.js",
-    "cloak": "./bin/repo-cloak.js"
+    "repo-cloak": "bin/repo-cloak.js",
+    "cloak": "bin/repo-cloak.js"
   },
   "scripts": {
     "start": "node bin/repo-cloak.js",
@@ -32,12 +32,13 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/iamshz97/repo-cloak.git"
+    "url": "git+https://github.com/iamshz97/repo-cloak.git"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "@inquirer/checkbox": "^5.1.2",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "figlet": "^1.7.0",
@@ -48,4 +49,4 @@
   "devDependencies": {
     "vitest": "^4.0.18"
   }
-}
+}

package/src/cli.js

@@ -32,6 +32,8 @@ program
     .option('-s, --source <path>', 'Source directory (default: current directory)')
     .option('-d, --dest <path>', 'Destination directory')
     .option('-f, --force', 'Force pull all files (skip prompts, requires existing mapping)')
+    .option('-c, --commit <hash...>', 'Extract files changed in specific commits')
+    .option('-l, --list-commits [count]', 'List and select from recent commits (default: 10)')
     .option('-q, --quiet', 'Minimal output')
     .action(async (options) => {
         await showBanner();

package/src/commands/pull.js

@@ -7,10 +7,10 @@
 import ora from 'ora';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import { existsSync, mkdirSync } from 'fs';
-import { resolve, relative } from 'path';
+import { existsSync, writeFileSync } from 'fs';
+import { resolve, relative, join } from 'path';
 
-import { selectFiles } from '../ui/fileSelector.js';
+import { checkboxTreeSelectFilesOnly } from '../ui/treeCheckboxSelector.js';
 import {
     promptSourceDirectory,
     promptDestinationDirectory,
@@ -20,12 +20,15 @@ import {
 } from '../ui/prompts.js';
 import { showSuccess, showError, showInfo } from '../ui/banner.js';
 import { getAllFiles } from '../core/scanner.js';
+import { scanFilesForSecrets } from '../core/secrets.js';
+import { getAgentsMarkdown } from '../core/agents-template.js';
 
 import { copyFiles } from '../core/copier.js';
 import { createAnonymizer } from '../core/anonymizer.js';
 import { createMapping, saveMapping, loadRawMapping, mergeMapping, hasMapping, decryptMapping } from '../core/mapper.js';
 import { getOrCreateSecret, hasSecret, decryptReplacements } from '../core/crypto.js';
-import { isGitRepo, getChangedFiles } from '../core/git.js';
+import { isGitRepo, getChangedFiles, getRecentCommits, getFilesChangedInCommits } from '../core/git.js';
+
 
 export async function pull(options = {}) {
     try {
@@ -38,6 +41,23 @@ export async function pull(options = {}) {
         // Step 1: Check if current directory is already a cloaked directory
         const currentDir = process.cwd();
 
+        // ── Step 2: Resolve sourceDir first (always ask source before destination) ──
+        if (!sourceDir) {
+            sourceDir = options.source
+                ? resolve(options.source)
+                : await promptSourceDirectory();
+        }
+
+        if (!existsSync(sourceDir)) {
+            showError(`Source directory does not exist: ${sourceDir}`);
+            return;
+        }
+
+        if (!options.force) {
+            console.log(chalk.dim(`   Source: ${sourceDir}\n`));
+        }
+
+        // ── Step 3: Resolve destDir ──
         if (hasMapping(currentDir) && !options.dest) {
             // Running from inside an existing cloaked directory - auto-detect!
             destDir = currentDir;
@@ -59,18 +79,18 @@ export async function pull(options = {}) {
                     {
                         type: 'list',
                         name: 'mode',
-                        message: 'What would you like to do?',
+                        message: 'This looks like a folder you already used — what do you want to do?',
                         choices: [
                             {
-                                name: 'Quick Add - Use existing replacements and add more files',
+                                name: 'Quick Add — keep existing settings and add more files',
                                 value: 'quick'
                             },
                             {
-                                name: 'Add More Replacements - Add files with additional anonymization',
+                                name: 'Add More Replacements — add files with extra anonymization',
                                 value: 'extend'
                             },
                             {
-                                name: 'Fresh Start - Choose new destination',
+                                name: 'Fresh Start — pick a new output folder',
                                 value: 'fresh'
                             }
                         ]
@@ -116,33 +136,9 @@ export async function pull(options = {}) {
                         console.log('');
                     }
                 }
-
-                // Try to get original source path
-                if (existingMapping.encrypted && hasSecret()) {
-                    const secret = getOrCreateSecret();
-                    try {
-                        const decrypted = decryptMapping(existingMapping, secret);
-                        if (decrypted.source?.path && existsSync(decrypted.source.path)) {
-                            sourceDir = decrypted.source.path;
-                            if (!options.force) {
-                                console.log(chalk.dim(`   Source: ${sourceDir}\n`));
-                            }
-                        }
-                    } catch (err) {
-                        // Source path couldn't be decrypted, will prompt
-                    }
-                } else if (!existingMapping.encrypted && existingMapping.source?.path) {
-                    // Not encrypted - use directly
-                    if (existsSync(existingMapping.source.path)) {
-                        sourceDir = existingMapping.source.path;
-                        if (!options.force) {
-                            console.log(chalk.dim(`   Source: ${sourceDir}\n`));
-                        }
-                    }
-                }
             }
         } else {
-            // Not running from a cloaked directory - ask for destination
+            // Not running from a cloaked directory
             if (options.force) {
                 showError('Force flag can only be used within an existing cloaked directory.');
                 return;
@@ -172,11 +168,11 @@ export async function pull(options = {}) {
                         {
                             type: 'list',
                             name: 'mode',
-                            message: 'What would you like to do?',
+                            message: 'This looks like a folder you already used — what do you want to do?',
                             choices: [
-                                { name: 'Quick Add - Use existing replacements and add more files', value: 'quick' },
-                                { name: 'Add More Replacements - Add files with additional anonymization', value: 'extend' },
-                                { name: 'Fresh Start - Choose new destination', value: 'fresh' }
+                                { name: 'Quick Add — keep existing settings and add more files', value: 'quick' },
+                                { name: 'Add More Replacements — add files with extra anonymization', value: 'extend' },
+                                { name: 'Fresh Start — pick a new output folder', value: 'fresh' }
                             ]
                         }
                     ]);
@@ -218,53 +214,11 @@ export async function pull(options = {}) {
                             console.log('');
                         }
                     }
-
-
-
-                    // Try to get original source path
-                    if (existingMapping.encrypted && hasSecret()) {
-                        const secret = getOrCreateSecret();
-                        try {
-                            const decrypted = decryptMapping(existingMapping, secret);
-                            if (decrypted.source?.path && existsSync(decrypted.source.path)) {
-                                sourceDir = decrypted.source.path;
-                                if (!options.force) {
-                                    console.log(chalk.dim(`   Source: ${sourceDir}\n`));
-                                }
-                            }
-                        } catch (err) {
-                            // Source path couldn't be decrypted, will prompt
-                        }
-                    } else if (!existingMapping.encrypted && existingMapping.source?.path) {
-                        if (existsSync(existingMapping.source.path)) {
-                            sourceDir = existingMapping.source.path;
-                            if (!options.force) {
-                                console.log(chalk.dim(`   Source: ${sourceDir}\n`));
-                            }
-                        }
-                    }
                 }
             }
         }
 
-        // ...
-
-        // Step 3: Get source directory if not already determined
-        if (!sourceDir) {
-            sourceDir = options.source
-                ? resolve(options.source)
-                : await promptSourceDirectory();
-        }
-
-        if (!existsSync(sourceDir)) {
-            showError(`Source directory does not exist: ${sourceDir}`);
-            return;
-        }
-
-        if (!options.force) {
-            console.log(chalk.dim(`   Source: ${sourceDir}\n`));
-        }
-
+        // ...\n
         // Step 4: Select files (Check for Git integration first)
         let selectedFiles = [];
         let useGitFiles = false;
@@ -358,67 +312,250 @@ export async function pull(options = {}) {
                 showError('No files found in existing mapping.');
                 return;
             }
+        } else if (!isGitRepo(sourceDir) && (options.commit || options.listCommits !== undefined)) {
+            showError('Source directory is not a Git repository. Cannot use commit flags.');
+            return;
         } else if (isGitRepo(sourceDir)) {
-            const { useGit } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'useGit',
-                    message: 'Git repository detected. Do you want to select changed/added files?',
-                    default: false
+            if (options.commit) {
+                const spinner = ora('Fetching files from commits...').start();
+                const commitFiles = await getFilesChangedInCommits(sourceDir, options.commit);
+                spinner.stop();
+
+                if (commitFiles.length === 0) {
+                    showError('No files found in the specified commits.');
+                    return;
+                }
+
+                // Filter to absolute paths and exist check
+                const validCommitFiles = commitFiles
+                    .map(f => resolve(sourceDir, f))
+                    .filter(f => existsSync(f));
+
+                if (validCommitFiles.length > 0) {
+                    console.log(chalk.green(`   Found ${validCommitFiles.length} files in specified commits.`));
+                    selectedFiles = validCommitFiles;
+                    useGitFiles = true;
+                } else {
+                    showError('None of the files from the specified commits exist locally.');
+                    return;
                 }
-            ]);
+            } else if (options.listCommits !== undefined) {
+                const count = options.listCommits === true ? 10 : parseInt(options.listCommits, 10) || 10;
+                const commits = await getRecentCommits(sourceDir, count);
 
-            if (useGit) {
-                const spinner = ora('Scanning changed files...').start();
-                const gitFiles = await getChangedFiles(sourceDir);
+                if (commits.length === 0) {
+                    showError('No commits found in the repository.');
+                    return;
+                }
+
+                const { selectedCommits } = await inquirer.prompt([
+                    {
+                        type: 'checkbox',
+                        name: 'selectedCommits',
+                        message: 'Which commits do you want to pull files from? (space to select, enter to confirm):', 
+                        choices: commits.map(c => ({
+                            name: `${c.hash} - ${c.message}`,
+                            value: c.hash
+                        }))
+                    }
+                ]);
+
+                if (selectedCommits.length === 0) {
+                    showError('No commits selected. Aborting.');
+                    return;
+                }
+
+                const spinner = ora('Fetching files from selected commits...').start();
+                const commitFiles = await getFilesChangedInCommits(sourceDir, selectedCommits);
                 spinner.stop();
+                
+                if (commitFiles.length === 0) {
+                    showError('No files found in the selected commits.');
+                    return;
+                }
+
+                const validCommitFiles = commitFiles
+                    .map(f => resolve(sourceDir, f))
+                    .filter(f => existsSync(f));
+
+                if (validCommitFiles.length > 0) {
+                    console.log(chalk.green(`   Found ${validCommitFiles.length} files in selected commits.`));
+                    selectedFiles = validCommitFiles;
+                    useGitFiles = true;
+                } else {
+                    showError('None of the files from the selected commits exist locally.');
+                    return;
+                }
+            } else {
+                const { gitAction } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'gitAction',
+                        message: 'This is a Git repo — how do you want to pick files?', 
+                        choices: [
+                            { name: 'Uncommitted changes (working directory)', value: 'uncommitted' },
+                            { name: 'Files from recent commits', value: 'commits' },
+                            { name: 'Specific commit ID', value: 'commit_id' },
+                            { name: 'Manual selection (bypasses git)', value: 'manual' }
+                        ]
+                    }
+                ]);
 
-                if (gitFiles.length === 0) {
-                    console.log(chalk.yellow('   No changed or added files found in Git status.'));
-                    const { fallback } = await inquirer.prompt([
+                if (gitAction === 'commit_id') {
+                    const { commitHash } = await inquirer.prompt([
                         {
-                            type: 'confirm',
-                            name: 'fallback',
-                            message: 'Do you want to manually select files instead?',
-                            default: true
+                            type: 'input',
+                            name: 'commitHash',
+                            message: 'Paste or type the commit hash you want to pull files from:', 
+                            validate: input => input.trim() !== '' ? true : 'Commit hash cannot be empty.'
                         }
                     ]);
 
-                    if (!fallback) {
-                        return;
-                    }
-                } else {
-                    // Filter to absolute paths and exist check
-                    const validGitFiles = gitFiles
-                        .map(f => resolve(sourceDir, f))
-                        .filter(f => existsSync(f));
+                    const spinner = ora(`Fetching files from commit ${commitHash}...`).start();
+                    const commitFiles = await getFilesChangedInCommits(sourceDir, [commitHash]);
+                    spinner.stop();
 
-                    if (validGitFiles.length > 0) {
-                        console.log(chalk.green(`   Found ${validGitFiles.length} changed files.`));
+                    if (commitFiles.length === 0) {
+                        console.log(chalk.yellow(`   No files found in commit ${commitHash} or invalid commit ID.`));
+                    } else {
+                        const validCommitFiles = commitFiles
+                            .map(f => resolve(sourceDir, f))
+                            .filter(f => existsSync(f));
+
+                        if (validCommitFiles.length > 0) {
+                            const allowedPaths = new Set(validCommitFiles);
+                            const allowedDirs = new Set();
+                            for (const file of validCommitFiles) {
+                                let dir = resolve(file, '..');
+                                while (dir && dir !== sourceDir && dir !== '/' && dir !== resolve(dir, '..')) {
+                                    allowedDirs.add(dir);
+                                    dir = resolve(dir, '..');
+                                }
+                            }
+                            allowedDirs.add(sourceDir);
+
+                            const pickedFiles = await checkboxTreeSelectFilesOnly({
+                                root: sourceDir,
+                                message: `Found ${validCommitFiles.length} files in commit ${commitHash} — uncheck any you want to skip:`,
+                                precheck: validCommitFiles,
+                                ignore: (fullPath, name) => {
+                                    return !(allowedPaths.has(fullPath) || allowedDirs.has(fullPath));
+                                }
+                            });
 
-                        // Let user confirm/deselect git files
-                        const { confirmGitFiles } = await inquirer.prompt([
+                            if (pickedFiles.length > 0) {
+                                selectedFiles = pickedFiles;
+                                useGitFiles = true;
+                            } else {
+                                console.log(chalk.yellow('   No files selected.'));
+                            }
+                        } else {
+                            console.log(chalk.yellow(`   None of the files from the specified commit exist locally.`));
+                        }
+                    }
+                } else if (gitAction === 'commits') {
+                    const commits = await getRecentCommits(sourceDir, 10);
+                    if (commits.length === 0) {
+                        console.log(chalk.yellow('   No commits found in the repository.'));
+                    } else {
+                        const { selectedCommits } = await inquirer.prompt([
                             {
                                 type: 'checkbox',
-                                name: 'confirmGitFiles',
-                                message: 'Select changed files to extract:',
-                                choices: validGitFiles.map(f => ({
-                                    name: relative(sourceDir, f),
-                                    value: f,
-                                    checked: true
+                                name: 'selectedCommits',
+                                message: 'Which commits do you want to pull files from? (space to select, enter to confirm):', 
+                                choices: commits.map(c => ({
+                                    name: `${c.hash} - ${c.message}`,
+                                    value: c.hash
                                 }))
                             }
                         ]);
 
-                        selectedFiles = confirmGitFiles;
-                        useGitFiles = true;
+                        if (selectedCommits.length > 0) {
+                            const spinner = ora('Fetching files from selected commits...').start();
+                            const commitFiles = await getFilesChangedInCommits(sourceDir, selectedCommits);
+                            spinner.stop();
+                            
+                            const validCommitFiles = commitFiles
+                                .map(f => resolve(sourceDir, f))
+                                .filter(f => existsSync(f));
+
+                            if (validCommitFiles.length > 0) {
+                                const allowedPaths = new Set(validCommitFiles);
+                                const allowedDirs = new Set();
+                                for (const file of validCommitFiles) {
+                                    let dir = resolve(file, '..');
+                                    while (dir && dir !== sourceDir && dir !== '/' && dir !== resolve(dir, '..')) {
+                                        allowedDirs.add(dir);
+                                        dir = resolve(dir, '..');
+                                    }
+                                }
+                                allowedDirs.add(sourceDir);
+
+                                const pickedFiles = await checkboxTreeSelectFilesOnly({
+                                    root: sourceDir,
+                                    message: `Found ${validCommitFiles.length} files across selected commits — uncheck any you want to skip:`,
+                                    precheck: validCommitFiles,
+                                    ignore: (fullPath, name) => {
+                                        return !(allowedPaths.has(fullPath) || allowedDirs.has(fullPath));
+                                    }
+                                });
+
+                                if (pickedFiles.length > 0) {
+                                    selectedFiles = pickedFiles;
+                                    useGitFiles = true;
+                                } else {
+                                    console.log(chalk.yellow('   No files selected.'));
+                                }
+                            } else {
+                                console.log(chalk.yellow('   None of the files from the selected commits exist locally.'));
+                            }
+                        }
+                    }
+                } else if (gitAction === 'uncommitted') {
+                    const spinner = ora('Scanning uncommitted files...').start();
+                    const gitFiles = await getChangedFiles(sourceDir);
+                    spinner.stop();
+
+                    if (gitFiles.length === 0) {
+                        console.log(chalk.yellow('   No uncommitted files found in Git status.'));
+                    } else {
+                        const validGitFiles = gitFiles
+                            .map(f => resolve(sourceDir, f))
+                            .filter(f => existsSync(f));
+
+                        if (validGitFiles.length > 0) {
+                            console.log(chalk.green(`   Found ${validGitFiles.length} changed files.`));
+
+                            const allowedPaths = new Set(validGitFiles);
+                            const allowedDirs = new Set();
+                            for (const file of validGitFiles) {
+                                let dir = resolve(file, '..');
+                                while (dir && dir !== sourceDir && dir !== '/' && dir !== resolve(dir, '..')) {
+                                    allowedDirs.add(dir);
+                                    dir = resolve(dir, '..');
+                                }
+                            }
+                            allowedDirs.add(sourceDir);
+
+                            const pickedFiles = await checkboxTreeSelectFilesOnly({
+                                root: sourceDir,
+                                message: 'Which changed files do you want to extract? (space to deselect):',
+                                precheck: validGitFiles,
+                                ignore: (fullPath, name) => {
+                                    return !(allowedPaths.has(fullPath) || allowedDirs.has(fullPath));
+                                }
+                            });
+
+                            selectedFiles = pickedFiles;
+                            useGitFiles = true;
+                        }
                     }
                 }
             }
         }
 
         if (!options.force && (!useGitFiles || selectedFiles.length === 0)) {
-            selectedFiles = await selectFiles(sourceDir);
+            selectedFiles = await checkboxTreeSelectFilesOnly({ root: sourceDir });
         }
 
         if (selectedFiles.length === 0) {
@@ -430,6 +567,48 @@ export async function pull(options = {}) {
             console.log(chalk.green(`\n✓ Selected ${selectedFiles.length} files\n`));
         }
 
+        // Step 4.5: Scan for Secrets
+        if (!options.force) {
+            const scanSpinner = ora('Scanning selected files for sensitive data...').start();
+            const secretFindings = await scanFilesForSecrets(selectedFiles);
+            scanSpinner.stop();
+
+            if (secretFindings.length > 0) {
+                console.log(chalk.red.bold('\n⚠️  WARNING: POTENTIAL SENSITIVE DATA DETECTED ⚠️\n'));
+                
+                // Group by file to present a cleaner list
+                const findingsByFile = secretFindings.reduce((acc, finding) => {
+                    const relPath = relative(sourceDir, finding.file);
+                    if (!acc[relPath]) acc[relPath] = new Set();
+                    acc[relPath].add(`${finding.type} (Line ${finding.line})`);
+                    return acc;
+                }, {});
+
+                for (const [file, secrets] of Object.entries(findingsByFile)) {
+                    console.log(chalk.yellow(`   ${file}:`));
+                    for (const secret of secrets) {
+                        console.log(chalk.dim(`      - ${secret}`));
+                    }
+                }
+                console.log('');
+
+                const { proceedWithSecrets } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'proceedWithSecrets',
+                        message: 'Some sensitive data was detected — are you sure you want to continue?', 
+                        default: false
+                    }
+                ]);
+
+                if (!proceedWithSecrets) {
+                    showInfo('Operation cancelled to protect sensitive data.');
+                    return;
+                }
+                console.log('');
+            }
+        }
+
         // Step 5: Handle replacements based on mode
         let replacements = [...existingReplacements];
 
@@ -445,7 +624,7 @@ export async function pull(options = {}) {
                     {
                         type: 'confirm',
                         name: 'addMore',
-                        message: 'Add additional replacements?',
+                        message: 'Want to add any more replacements?', 
                         default: false
                     }
                 ]);
@@ -479,12 +658,6 @@ export async function pull(options = {}) {
             }
         }
 
-        // Step 7: Create destination directory
-        if (!existsSync(destDir)) {
-            mkdirSync(destDir, { recursive: true });
-            console.log(chalk.dim(`   Created directory: ${destDir}`));
-        }
-
         // Step 8: Copy and anonymize files
         const spinner = ora('Copying and anonymizing files...').start();
 
@@ -520,6 +693,13 @@ export async function pull(options = {}) {
             });
         }
 
+        // Step 8.5: Write AGENTS.md into the cloaked workspace
+        if (!existingMapping) {
+            const agentsPath = join(destDir, 'AGENTS.md');
+            writeFileSync(agentsPath, getAgentsMarkdown(), 'utf-8');
+            console.log(chalk.cyan(`   🤖 AGENTS.md created for AI agent context`));
+        }
+
         // Step 9: Prepare new file mappings
         const newFiles = selectedFiles.map(f => {
             const originalPath = relative(sourceDir, f);

package/src/core/agents-template.js

@@ -0,0 +1,37 @@
+/**
+ * AGENTS.md Template
+ * Auto-generated file placed inside cloaked workspaces to instruct AI agents
+ * about the nature of the isolated, anonymized repository.
+ */
+
+export function getAgentsMarkdown() {
+    return `# AI Agent Guidelines for This Repository
+
+## Important Context
+
+This is an **isolated, partially cloned repository** created using [Repo-Cloak](https://www.npmjs.com/package/repo-cloak-cli). It contains only a subset of files selectively pulled from a larger enterprise codebase for the purpose of working with AI coding tools in a safe, anonymized environment.
+
+## What You Need to Know
+
+- **Partial repository.** This workspace does NOT contain the full codebase. Only specific files were selected and pulled by the developer. Missing files, references, or imports pointing to modules not present in this workspace are expected.
+- **Anonymized identifiers.** Company names, project names, and other proprietary identifiers have been systematically replaced with anonymized alternatives. Do not attempt to guess or restore the original names.
+- **Preserve the existing structure.** All file paths, folder hierarchies, and naming conventions in this workspace mirror the original repository structure. Maintain this structure in any changes you make.
+- **Only modify files present in this workspace.** Do not create files outside the directories already present unless explicitly asked to by the user. Your changes will be pushed back into the original repository, so they must align with the existing structure.
+
+## If You Need More Context
+
+If you encounter a situation where:
+- A referenced file, module, or dependency is missing
+- You cannot determine the correct interface, type, or contract
+- The available code is insufficient to complete the task confidently
+
+**Ask the user to pull additional files** using Repo-Cloak. They can selectively add more files to this workspace without starting over. Do not guess or fabricate missing implementations.
+
+## Working With This Repository
+
+1. Treat this workspace as a real project. The structure and patterns are genuine.
+2. Write code that follows the conventions and patterns you observe in the existing files.
+3. Your changes will be de-anonymized and merged back into the original codebase automatically.
+4. Focus on the task the user has given you. The files present are the files they have chosen to expose for this purpose.
+`;
+}