repo-cloak-cli 1.0.0

package/src/core/anonymizer.js

@@ -0,0 +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;
+}

package/src/core/copier.js

@@ -0,0 +1,96 @@
+/**
+ * File Copier
+ * Copies files while preserving directory structure
+ */
+
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, relative } from 'path';
+import { isBinaryFile } from './scanner.js';
+
+/**
+ * Copy a single file, creating directories as needed
+ */
+export function copyFile(sourcePath, destPath) {
+    // Ensure destination directory exists
+    const destDir = dirname(destPath);
+    mkdirSync(destDir, { recursive: true });
+
+    // Copy the file
+    copyFileSync(sourcePath, destPath);
+}
+
+/**
+ * Copy a file with content transformation
+ */
+export function copyFileWithTransform(sourcePath, destPath, transformFn) {
+    // Ensure destination directory exists
+    const destDir = dirname(destPath);
+    mkdirSync(destDir, { recursive: true });
+
+    // Check if binary - copy as-is
+    if (isBinaryFile(sourcePath)) {
+        copyFileSync(sourcePath, destPath);
+        return { transformed: false };
+    }
+
+    // Read, transform, write
+    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) {
+        // If reading as text fails, copy as binary
+        copyFileSync(sourcePath, destPath);
+        return { transformed: false, error: error.message };
+    }
+}
+
+/**
+ * Copy multiple files with progress callback
+ */
+export async function copyFiles(files, sourceBase, destBase, transformFn, onProgress) {
+    const results = {
+        total: files.length,
+        copied: 0,
+        transformed: 0,
+        errors: []
+    };
+
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const relativePath = typeof file === 'string'
+            ? relative(sourceBase, file)
+            : file.relativePath;
+        const sourcePath = typeof file === 'string' ? file : file.absolutePath;
+        const destPath = join(destBase, relativePath);
+
+        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: relativePath,
+                error: error.message
+            });
+        }
+
+        if (onProgress) {
+            onProgress(i + 1, files.length, relativePath);
+        }
+    }
+
+    return results;
+}

package/src/core/mapper.js

@@ -0,0 +1,120 @@
+/**
+ * Mapping File Manager
+ * Tracks replacements and file mappings for push/pull operations
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const MAP_FILENAME = '.repo-cloak-map.json';
+
+/**
+ * Create a mapping object
+ */
+export function createMapping(options) {
+    const {
+        sourceDir,
+        destDir,
+        replacements,
+        files,
+        timestamp = new Date().toISOString()
+    } = options;
+
+    return {
+        version: '1.0.0',
+        tool: 'repo-cloak',
+        timestamp,
+        source: {
+            path: sourceDir,
+            platform: process.platform
+        },
+        destination: {
+            path: destDir
+        },
+        replacements: replacements.map(r => ({
+            original: r.original,
+            replacement: r.replacement
+        })),
+        files: files.map(f => ({
+            original: typeof f === 'string' ? f : f.relativePath,
+            cloaked: typeof f === 'string' ? f : f.relativePath
+        })),
+        stats: {
+            totalFiles: files.length,
+            replacementsCount: replacements.length
+        }
+    };
+}
+
+/**
+ * Save mapping to destination directory
+ */
+export function saveMapping(destDir, mapping) {
+    const mapPath = join(destDir, MAP_FILENAME);
+    writeFileSync(mapPath, JSON.stringify(mapping, null, 2), 'utf-8');
+    return mapPath;
+}
+
+/**
+ * Load mapping from a cloaked directory
+ */
+export function loadMapping(cloakedDir) {
+    const mapPath = join(cloakedDir, MAP_FILENAME);
+
+    if (!existsSync(mapPath)) {
+        throw new Error(`No mapping file found in ${cloakedDir}. Is this a repo-cloak backup?`);
+    }
+
+    try {
+        const content = readFileSync(mapPath, 'utf-8');
+        return JSON.parse(content);
+    } catch (error) {
+        throw new Error(`Failed to read mapping file: ${error.message}`);
+    }
+}
+
+/**
+ * Check if a directory has a mapping file
+ */
+export function hasMapping(dir) {
+    const mapPath = join(dir, MAP_FILENAME);
+    return existsSync(mapPath);
+}
+
+/**
+ * Get the original source path from mapping
+ */
+export function getOriginalSource(mapping) {
+    return mapping.source?.path || null;
+}
+
+/**
+ * Get replacements from mapping
+ */
+export function getReplacements(mapping) {
+    return mapping.replacements || [];
+}
+
+/**
+ * Get file list from mapping
+ */
+export function getFiles(mapping) {
+    return mapping.files || [];
+}
+
+/**
+ * Update mapping with additional info
+ */
+export function updateMapping(destDir, updates) {
+    const mapPath = join(destDir, MAP_FILENAME);
+
+    if (!existsSync(mapPath)) {
+        throw new Error('No mapping file found');
+    }
+
+    const mapping = loadMapping(destDir);
+    const updated = { ...mapping, ...updates, updatedAt: new Date().toISOString() };
+
+    writeFileSync(mapPath, JSON.stringify(updated, null, 2), 'utf-8');
+    return updated;
+}

package/src/core/scanner.js

@@ -0,0 +1,137 @@
+/**
+ * Directory Scanner
+ * Scans and builds file tree structure
+ */
+
+import { readdirSync, statSync } from 'fs';
+import { join, relative, sep, extname } from 'path';
+
+// Binary file extensions to copy without modification
+const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
+    '.mp3', '.mp4', '.wav', '.avi', '.mov', '.mkv', '.webm',
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    '.zip', '.rar', '.7z', '.tar', '.gz', '.bz2',
+    '.exe', '.dll', '.so', '.dylib', '.bin',
+    '.ttf', '.otf', '.woff', '.woff2', '.eot',
+    '.sqlite', '.db', '.mdb'
+]);
+
+// Directories to always ignore
+const IGNORE_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    '.DS_Store',
+    'Thumbs.db',
+    '.idea',
+    '.vscode',
+    '__pycache__',
+    '.pytest_cache',
+    'dist',
+    'build',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '.nyc_output',
+    '.repo-cloak-map.json',
+    '.env',
+    '.env.local'
+]);
+
+/**
+ * Check if a file is binary based on extension
+ */
+export function isBinaryFile(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return BINARY_EXTENSIONS.has(ext);
+}
+
+/**
+ * Check if a file/folder should be ignored
+ */
+export function shouldIgnore(name) {
+    return IGNORE_DIRS.has(name) || name.startsWith('.');
+}
+
+/**
+ * Recursively get all files in a directory
+ */
+export function getAllFiles(dir, basePath = dir, files = []) {
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+
+            if (shouldIgnore(entry.name)) continue;
+
+            if (entry.isDirectory()) {
+                getAllFiles(fullPath, basePath, files);
+            } else {
+                files.push({
+                    absolutePath: fullPath,
+                    relativePath: relative(basePath, fullPath),
+                    name: entry.name,
+                    isBinary: isBinaryFile(fullPath)
+                });
+            }
+        }
+    } catch (error) {
+        // Permission denied or other errors - skip
+    }
+
+    return files;
+}
+
+/**
+ * Get directory structure for display
+ */
+export function getDirectoryTree(dir, basePath = dir, depth = 0, maxDepth = 5) {
+    const tree = [];
+
+    if (depth > maxDepth) return tree;
+
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+
+        // Sort: folders first, then files
+        entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory()) return -1;
+            if (!a.isDirectory() && b.isDirectory()) return 1;
+            return a.name.localeCompare(b.name);
+        });
+
+        for (const entry of entries) {
+            if (shouldIgnore(entry.name)) continue;
+
+            const fullPath = join(dir, entry.name);
+            const node = {
+                name: entry.name,
+                path: fullPath,
+                relativePath: relative(basePath, fullPath),
+                isDirectory: entry.isDirectory(),
+                depth
+            };
+
+            tree.push(node);
+
+            if (entry.isDirectory()) {
+                const children = getDirectoryTree(fullPath, basePath, depth + 1, maxDepth);
+                tree.push(...children);
+            }
+        }
+    } catch (error) {
+        // Skip inaccessible directories
+    }
+
+    return tree;
+}
+
+/**
+ * Count files in a directory (recursive)
+ */
+export function countFiles(dir) {
+    return getAllFiles(dir).length;
+}

package/src/index.js

@@ -0,0 +1,8 @@
+/**
+ * repo-cloak - Main exports
+ * 🎭 Selectively extract and anonymize files from repositories
+ */
+
+export { pull } from './commands/pull.js';
+export { push } from './commands/push.js';
+export { showBanner } from './ui/banner.js';

package/src/ui/banner.js

@@ -0,0 +1,70 @@
+/**
+ * Fancy ASCII Banner
+ * Shows a colorful intro when the CLI starts
+ */
+
+import chalk from 'chalk';
+import figlet from 'figlet';
+
+export async function showBanner() {
+    return new Promise((resolve) => {
+        figlet.text('repo-cloak', {
+            font: 'Standard',
+            horizontalLayout: 'default',
+            verticalLayout: 'default'
+        }, (err, data) => {
+            if (err) {
+                console.log(chalk.magentaBright.bold('\n🎭 repo-cloak\n'));
+                resolve();
+                return;
+            }
+
+            // Create gradient effect
+            const lines = data.split('\n');
+            const colors = [
+                chalk.hex('#FF6B6B'),  // Coral
+                chalk.hex('#FF8E53'),  // Orange
+                chalk.hex('#FEC89A'),  // Peach
+                chalk.hex('#A8E6CF'),  // Mint
+                chalk.hex('#88D8B0'),  // Seafoam
+                chalk.hex('#7B68EE'),  // Medium Slate Blue
+                chalk.hex('#9D4EDD'),  // Purple
+            ];
+
+            console.log('\n');
+            lines.forEach((line, index) => {
+                const color = colors[index % colors.length];
+                console.log(color(line));
+            });
+
+            // Tagline box
+            const tagline = '🎭 Selectively extract & anonymize repository files';
+            const version = 'v1.0.0';
+
+            console.log('');
+            console.log(chalk.dim('─'.repeat(55)));
+            console.log(chalk.white.bold(`  ${tagline}`));
+            console.log(chalk.dim(`  Compatible with Windows, macOS, and Linux | ${version}`));
+            console.log(chalk.dim('─'.repeat(55)));
+            console.log('');
+
+            resolve();
+        });
+    });
+}
+
+export function showSuccess(message) {
+    console.log(chalk.green.bold(`\n✅ ${message}\n`));
+}
+
+export function showError(message) {
+    console.log(chalk.red.bold(`\n❌ ${message}\n`));
+}
+
+export function showWarning(message) {
+    console.log(chalk.yellow.bold(`\n⚠️  ${message}\n`));
+}
+
+export function showInfo(message) {
+    console.log(chalk.cyan(`\nℹ️  ${message}\n`));
+}