repo-cloak-cli 1.3.2 → 1.3.4

package/tests/git.test.js

@@ -3,7 +3,7 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { isGitRepo, getChangedFiles } from '../src/core/git.js';
+import { isGitRepo, getChangedFiles, getRecentCommits, getFilesChangedInCommits } from '../src/core/git.js';
 import { existsSync, mkdirSync, writeFileSync, rmSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
@@ -100,4 +100,62 @@ describe('Git Module', () => {
             expect(files).not.toContain('old.txt');
         });
     });
+
+    describe('getRecentCommits', () => {
+        it('should return empty array for empty repo', async () => {
+            initGitRepo(testDir);
+            const commits = await getRecentCommits(testDir, 10);
+            expect(commits).toEqual([]);
+        });
+
+        it('should return recent commits', async () => {
+            initGitRepo(testDir);
+            writeFileSync(join(testDir, 'test1.txt'), 'test1');
+            execSync('git add test1.txt', { cwd: testDir });
+            execSync('git commit -m "first commit"', { cwd: testDir });
+
+            writeFileSync(join(testDir, 'test2.txt'), 'test2');
+            execSync('git add test2.txt', { cwd: testDir });
+            execSync('git commit -m "second commit"', { cwd: testDir });
+
+            const commits = await getRecentCommits(testDir, 10);
+            expect(commits).toHaveLength(2);
+            expect(commits[0].message).toBe('second commit');
+            expect(commits[0].hash.length).toBeGreaterThan(0);
+            expect(commits[1].message).toBe('first commit');
+        });
+    });
+
+    describe('getFilesChangedInCommits', () => {
+        it('should return empty array if no commits provided', async () => {
+            initGitRepo(testDir);
+            const files = await getFilesChangedInCommits(testDir, []);
+            expect(files).toEqual([]);
+        });
+
+        it('should return files changed in specific commits', async () => {
+            initGitRepo(testDir);
+            writeFileSync(join(testDir, 'test1.txt'), 'test1');
+            execSync('git add test1.txt', { cwd: testDir });
+            execSync('git commit -m "first commit"', { cwd: testDir });
+            
+            const firstCommitHash = execSync('git rev-parse HEAD', { cwd: testDir }).toString().trim();
+
+            writeFileSync(join(testDir, 'test2.txt'), 'test2');
+            execSync('git add test2.txt', { cwd: testDir });
+            execSync('git commit -m "second commit"', { cwd: testDir });
+
+            const secondCommitHash = execSync('git rev-parse HEAD', { cwd: testDir }).toString().trim();
+
+            const filesFirst = await getFilesChangedInCommits(testDir, [firstCommitHash]);
+            expect(filesFirst).toEqual(['test1.txt']);
+
+            const filesSecond = await getFilesChangedInCommits(testDir, [secondCommitHash]);
+            expect(filesSecond).toEqual(['test2.txt']);
+
+            const bothFiles = await getFilesChangedInCommits(testDir, [firstCommitHash, secondCommitHash]);
+            expect(bothFiles.sort()).toEqual(['test1.txt', 'test2.txt']);
+        });
+    });
 });
+

package/tests/path-cache.test.js

@@ -0,0 +1,164 @@
+/**
+ * Path Cache Module Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, rmSync, mkdirSync } from 'fs';
+
+// Use createRequire inside vi.hoisted so we can call path/os before ES imports are resolved
+const { testConfigDir } = vi.hoisted(() => {
+    // eslint-disable-next-line no-undef
+    const os = require('os');
+    // eslint-disable-next-line no-undef
+    const path = require('path');
+    return {
+        testConfigDir: path.join(os.tmpdir(), `repo-cloak-path-cache-test-${Date.now()}`)
+    };
+});
+
+vi.mock('../src/core/crypto.js', () => ({
+    hasSecret: () => true,
+    getOrCreateSecret: () => 'test-secret-key',
+    encrypt: (text) => `enc:${text}`,
+    decrypt: (text) => (text.startsWith('enc:') ? text.slice(4) : null)
+}));
+
+vi.mock('../src/core/path-cache.js', async () => {
+    const { hasSecret, getOrCreateSecret, encrypt, decrypt } = await import('../src/core/crypto.js');
+    const { existsSync: fsExists, readFileSync, writeFileSync, mkdirSync: fsMkdir } = await import('fs');
+    const path = await import('path');
+
+    const CACHE_FILE = path.join(testConfigDir, 'path-cache.json');
+    const MAX_PATHS = 10;
+
+    function loadRawCache() {
+        try {
+            if (!fsExists(CACHE_FILE)) return { sources: [], destinations: [] };
+            const parsed = JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+            return {
+                sources: Array.isArray(parsed.sources) ? parsed.sources : [],
+                destinations: Array.isArray(parsed.destinations) ? parsed.destinations : []
+            };
+        } catch { return { sources: [], destinations: [] }; }
+    }
+
+    function saveRawCache(cache) {
+        if (!fsExists(testConfigDir)) fsMkdir(testConfigDir, { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+    }
+
+    function decryptPaths(encrypted, secret) {
+        return encrypted.map(e => { try { return decrypt(e, secret); } catch { return null; } }).filter(Boolean);
+    }
+
+    return {
+        getSourcePaths: () => {
+            if (!hasSecret()) return [];
+            return decryptPaths(loadRawCache().sources, getOrCreateSecret());
+        },
+        getDestPaths: () => {
+            if (!hasSecret()) return [];
+            return decryptPaths(loadRawCache().destinations, getOrCreateSecret());
+        },
+        addSourcePath: (p) => {
+            const secret = getOrCreateSecret();
+            const cache = loadRawCache();
+            const existing = decryptPaths(cache.sources, secret);
+            const deduped = [p, ...existing.filter(x => x !== p)].slice(0, MAX_PATHS);
+            cache.sources = deduped.map(x => encrypt(x, secret));
+            saveRawCache(cache);
+        },
+        addDestPath: (p) => {
+            const secret = getOrCreateSecret();
+            const cache = loadRawCache();
+            const existing = decryptPaths(cache.destinations, secret);
+            const deduped = [p, ...existing.filter(x => x !== p)].slice(0, MAX_PATHS);
+            cache.destinations = deduped.map(x => encrypt(x, secret));
+            saveRawCache(cache);
+        }
+    };
+});
+
+import { getSourcePaths, getDestPaths, addSourcePath, addDestPath } from '../src/core/path-cache.js';
+
+describe('Path Cache Module', () => {
+    beforeEach(() => {
+        if (existsSync(testConfigDir)) rmSync(testConfigDir, { recursive: true, force: true });
+        mkdirSync(testConfigDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (existsSync(testConfigDir)) rmSync(testConfigDir, { recursive: true, force: true });
+    });
+
+    describe('getSourcePaths', () => {
+        it('returns empty array when no cache exists', () => {
+            expect(getSourcePaths()).toEqual([]);
+        });
+
+        it('returns previously added source paths', () => {
+            addSourcePath('/path/to/repo');
+            expect(getSourcePaths()).toContain('/path/to/repo');
+        });
+    });
+
+    describe('getDestPaths', () => {
+        it('returns empty array when no cache exists', () => {
+            expect(getDestPaths()).toEqual([]);
+        });
+
+        it('returns previously added destination paths', () => {
+            addDestPath('/path/to/output');
+            expect(getDestPaths()).toContain('/path/to/output');
+        });
+    });
+
+    describe('addSourcePath', () => {
+        it('adds multiple paths and returns most recent first', () => {
+            addSourcePath('/first');
+            addSourcePath('/second');
+            addSourcePath('/third');
+
+            const paths = getSourcePaths();
+            expect(paths[0]).toBe('/third');
+            expect(paths[1]).toBe('/second');
+            expect(paths[2]).toBe('/first');
+        });
+
+        it('deduplicates paths, moving existing path to front', () => {
+            addSourcePath('/a');
+            addSourcePath('/b');
+            addSourcePath('/a');
+
+            const paths = getSourcePaths();
+            expect(paths[0]).toBe('/a');
+            expect(paths.filter(p => p === '/a')).toHaveLength(1);
+        });
+
+        it('caps at MAX_PATHS (10) entries', () => {
+            for (let i = 0; i < 15; i++) addSourcePath(`/path/${i}`);
+            expect(getSourcePaths().length).toBeLessThanOrEqual(10);
+        });
+    });
+
+    describe('addDestPath', () => {
+        it('adds multiple destination paths and returns most recent first', () => {
+            addDestPath('/out/a');
+            addDestPath('/out/b');
+
+            const paths = getDestPaths();
+            expect(paths[0]).toBe('/out/b');
+            expect(paths[1]).toBe('/out/a');
+        });
+
+        it('deduplicates destination paths', () => {
+            addDestPath('/out/x');
+            addDestPath('/out/y');
+            addDestPath('/out/x');
+
+            const paths = getDestPaths();
+            expect(paths[0]).toBe('/out/x');
+            expect(paths.filter(p => p === '/out/x')).toHaveLength(1);
+        });
+    });
+});

package/tests/secrets.test.js

@@ -0,0 +1,93 @@
+/**
+ * Secrets Detection Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { scanFileForSecrets, scanFilesForSecrets } from '../src/core/secrets.js';
+import { existsSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('Secrets Module', () => {
+    let testDir;
+
+    beforeEach(() => {
+        testDir = join(tmpdir(), `repo-cloak-secrets-test-${Date.now()}`);
+        mkdirSync(testDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            try {
+                rmSync(testDir, { recursive: true, force: true });
+            } catch (e) {
+                // Ignore cleanup errors
+            }
+        }
+    });
+
+    describe('scanFileForSecrets', () => {
+        it('should detect AWS Access Keys', () => {
+            const filePath = join(testDir, 'aws.env');
+            writeFileSync(filePath, 'AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE\n');
+            
+            const findings = scanFileForSecrets(filePath);
+            expect(findings).toHaveLength(1);
+            expect(findings[0].type).toBe('AWS Access Key ID');
+            expect(findings[0].line).toBe(1);
+        });
+
+        it('should detect generic API keys', () => {
+            const filePath = join(testDir, 'config.js');
+            writeFileSync(filePath, `
+                const config = {
+                    api_key: "abc123DEF456ghi789jkl012mno",
+                    port: 8080
+                };
+            `);
+            
+            const findings = scanFileForSecrets(filePath);
+            expect(findings.length).toBeGreaterThan(0);
+            expect(findings[0].type).toBe('Generic API Key / Token');
+        });
+
+        it('should not detect harmless text', () => {
+            const filePath = join(testDir, 'readme.md');
+            writeFileSync(filePath, 'This is a normal file without secrets.\nAPI keys are good.\n');
+            
+            const findings = scanFileForSecrets(filePath);
+            expect(findings).toHaveLength(0);
+        });
+
+        it('should detect multiple secrets in one file', () => {
+            const filePath = join(testDir, 'keys.txt');
+            writeFileSync(filePath, 'AKIAIOSFODNN7EXAMPLE\nghp_123456789012345678901234567890123456\n');
+            
+            const findings = scanFileForSecrets(filePath);
+            expect(findings).toHaveLength(2);
+            expect(findings.find(f => f.type === 'AWS Access Key ID')).toBeDefined();
+            expect(findings.find(f => f.type === 'GitHub Token')).toBeDefined();
+        });
+
+        it('should ignore binary files', () => {
+            const filePath = join(testDir, 'image.png');
+            writeFileSync(filePath, 'AKIAIOSFODNN7EXAMPLE'); // Test content but .png extension
+            
+            const findings = scanFileForSecrets(filePath);
+            expect(findings).toHaveLength(0);
+        });
+    });
+
+    describe('scanFilesForSecrets', async () => {
+        it('should aggregate findings from multiple files', async () => {
+            const file1 = join(testDir, 'f1.txt');
+            writeFileSync(file1, 'AKIAIOSFODNN7EXAMPLE');
+
+            const file2 = join(testDir, 'f2.txt');
+            writeFileSync(file2, 'ghp_123456789012345678901234567890123456');
+
+            const findings = await scanFilesForSecrets([file1, file2]);
+            expect(findings).toHaveLength(2);
+        });
+    });
+});

package/.github/workflows/release.yml

@@ -1,92 +0,0 @@
-name: Release & Publish
-
-on:
-  # Manual trigger with version bump
-  workflow_dispatch:
-    inputs:
-      version_type:
-        description: 'Version bump type'
-        required: true
-        default: 'patch'
-        type: choice
-        options:
-          - patch
-          - minor
-          - major
-
-  # Auto-publish on push (only if version changed)
-  push:
-    branches:
-      - main
-      - master
-    paths:
-      - 'package.json'
-      - 'src/**'
-      - 'bin/**'
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: 🎭 Checkout repository
-        uses: actions/checkout@v4
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          fetch-depth: 0
-
-      - name: 📦 Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: 🔧 Configure Git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: 📥 Install dependencies
-        run: npm ci
-
-      - name: 📝 Bump version (manual trigger only)
-        if: github.event_name == 'workflow_dispatch'
-        run: |
-          npm version ${{ inputs.version_type }} -m "chore: release v%s"
-          git push --follow-tags
-
-      - name: 🔍 Check if version exists on npm
-        id: check_version
-        run: |
-          PACKAGE_NAME=$(node -p "require('./package.json').name")
-          LOCAL_VERSION=$(node -p "require('./package.json').version")
-          
-          # Check if this version already exists on npm
-          NPM_VERSION=$(npm view $PACKAGE_NAME version 2>/dev/null || echo "0.0.0")
-          
-          echo "Local version: $LOCAL_VERSION"
-          echo "npm version: $NPM_VERSION"
-          
-          if [ "$LOCAL_VERSION" = "$NPM_VERSION" ]; then
-            echo "should_publish=false" >> $GITHUB_OUTPUT
-            echo "⏭️ Version $LOCAL_VERSION already exists on npm, skipping publish"
-          else
-            echo "should_publish=true" >> $GITHUB_OUTPUT
-            echo "✅ Version $LOCAL_VERSION is new, will publish"
-          fi
-
-      - name: 🚀 Publish to npm
-        if: steps.check_version.outputs.should_publish == 'true'
-        run: |
-          npm config set //registry.npmjs.org/:_authToken ${{ secrets.NPM_TOKEN }}
-          npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: ✅ Done
-        run: |
-          if [ "${{ steps.check_version.outputs.should_publish }}" = "true" ]; then
-            echo "🎉 Published successfully!"
-          else
-            echo "ℹ️ No publish needed - version unchanged"
-          fi

package/src/ui/fileSelector.js

@@ -1,256 +0,0 @@
-/**
- * Interactive File Selector
- * Hierarchical tree view with pagination
- */
-
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import { readdirSync } from 'fs';
-import { join, relative, sep } from 'path';
-
-// 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',
-    'obj', 'bin', 'packages', '.vs', 'TestResults'
-]);
-
-const PAGE_SIZE = 50;
-
-function shouldIgnore(name) {
-    return IGNORE_DIRS.has(name) || name.startsWith('.');
-}
-
-function buildFileIndex(baseDir, maxDepth = 8) {
-    const files = [];
-
-    function scan(dir, depth = 0) {
-        if (depth > maxDepth) return;
-
-        try {
-            const entries = readdirSync(dir, { withFileTypes: true });
-
-            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 relativePath = relative(baseDir, fullPath);
-
-                files.push({
-                    name: entry.name,
-                    path: fullPath,
-                    relativePath,
-                    isDirectory: entry.isDirectory(),
-                    depth
-                });
-
-                if (entry.isDirectory()) {
-                    scan(fullPath, depth + 1);
-                }
-            }
-        } catch (error) { }
-    }
-
-    scan(baseDir);
-    return files;
-}
-
-function getFilesInDirectory(dir) {
-    const files = [];
-
-    function collect(currentDir) {
-        try {
-            const entries = readdirSync(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (shouldIgnore(entry.name)) continue;
-                const fullPath = join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    collect(fullPath);
-                } else {
-                    files.push(fullPath);
-                }
-            }
-        } catch (error) { }
-    }
-
-    collect(dir);
-    return files;
-}
-
-function formatTreeItem(item) {
-    const indent = '  '.repeat(item.depth);
-    const icon = item.isDirectory ? '📁' : '📄';
-    const name = item.isDirectory
-        ? chalk.blue.bold(item.name)
-        : chalk.white(item.name);
-    return `${indent}${icon} ${name}`;
-}
-
-/**
- * Show paginated results with Load More option
- */
-async function showPaginatedResults(filtered, selectedPaths, page = 0) {
-    const start = page * PAGE_SIZE;
-    const end = Math.min(start + PAGE_SIZE, filtered.length);
-    const pageItems = filtered.slice(start, end);
-    const hasMore = end < filtered.length;
-    const remaining = filtered.length - end;
-
-    // Build choices
-    const choices = pageItems.map(f => {
-        let isChecked = false;
-        if (f.isDirectory) {
-            const childFiles = getFilesInDirectory(f.path);
-            isChecked = childFiles.length > 0 && childFiles.every(fp => selectedPaths.has(fp));
-        } else {
-            isChecked = selectedPaths.has(f.path);
-        }
-
-        return {
-            name: formatTreeItem(f),
-            value: f,
-            checked: isChecked,
-            short: f.relativePath
-        };
-    });
-
-    // Add separator and load more option if there are more results
-    if (hasMore) {
-        choices.push(new inquirer.Separator(chalk.dim('─────────────────────────────')));
-        choices.push({
-            name: chalk.cyan(`⏬ Load next ${Math.min(PAGE_SIZE, remaining)} items (${remaining} remaining)`),
-            value: '__LOAD_MORE__',
-            short: 'Load more'
-        });
-    }
-
-    const pageInfo = `Page ${page + 1} (${start + 1}-${end} of ${filtered.length})`;
-
-    const { picked } = await inquirer.prompt([
-        {
-            type: 'checkbox',
-            name: 'picked',
-            message: `${pageInfo}:`,
-            choices,
-            pageSize: 25,
-            loop: false
-        }
-    ]);
-
-    return { picked, pageItems, hasMore };
-}
-
-export async function selectFiles(sourceDir) {
-    console.log(chalk.cyan('\n📂 Scanning directory...'));
-
-    const fileIndex = buildFileIndex(sourceDir);
-    console.log(chalk.dim(`   Found ${fileIndex.length} items\n`));
-
-    if (fileIndex.length === 0) {
-        console.log(chalk.yellow('   No files found.'));
-        return [];
-    }
-
-    const selectedPaths = new Set();
-    let continueLoop = true;
-
-    console.log(chalk.cyan('🔍 File Selection'));
-    console.log(chalk.dim('   • Type to filter → Space to tick → Enter to confirm'));
-    console.log(chalk.dim('   • Select "Load more" to see next batch'));
-    console.log(chalk.dim('   • Empty search = done\n'));
-
-    while (continueLoop) {
-        if (selectedPaths.size > 0) {
-            console.log(chalk.green(`\n   📦 ${selectedPaths.size} file(s) selected`));
-        }
-
-        const { searchTerm } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'searchTerm',
-                message: 'Filter (empty = done):',
-                prefix: '🔎'
-            }
-        ]);
-
-        if (!searchTerm.trim()) {
-            if (selectedPaths.size === 0) {
-                const { confirmExit } = await inquirer.prompt([
-                    { type: 'confirm', name: 'confirmExit', message: 'No files selected. Exit?', default: false }
-                ]);
-                if (confirmExit) continueLoop = false;
-            } else {
-                continueLoop = false;
-            }
-            continue;
-        }
-
-        // Filter by search term
-        const query = searchTerm.toLowerCase();
-        const filtered = fileIndex.filter(f =>
-            f.relativePath.toLowerCase().includes(query) ||
-            f.name.toLowerCase().includes(query)
-        );
-
-        if (filtered.length === 0) {
-            console.log(chalk.yellow('   No matches found.'));
-            continue;
-        }
-
-        console.log(chalk.dim(`   Found ${filtered.length} matches`));
-
-        // Pagination loop
-        let page = 0;
-        let continuePaging = true;
-
-        while (continuePaging) {
-            const { picked, pageItems, hasMore } = await showPaginatedResults(filtered, selectedPaths, page);
-
-            // Check if user selected "Load More"
-            const loadMore = picked.find(p => p === '__LOAD_MORE__');
-            const actualPicks = picked.filter(p => p !== '__LOAD_MORE__');
-
-            // Process deselections for this page
-            const pickedPaths = new Set(actualPicks.map(p => p.path));
-            for (const f of pageItems) {
-                if (!pickedPaths.has(f.path)) {
-                    if (f.isDirectory) {
-                        const childFiles = getFilesInDirectory(f.path);
-                        childFiles.forEach(fp => selectedPaths.delete(fp));
-                    } else {
-                        selectedPaths.delete(f.path);
-                    }
-                }
-            }
-
-            // Process selections
-            for (const f of actualPicks) {
-                if (f.isDirectory) {
-                    const childFiles = getFilesInDirectory(f.path);
-                    childFiles.forEach(fp => selectedPaths.add(fp));
-                    console.log(chalk.green(`   + 📁 ${f.relativePath}/ (${childFiles.length} files)`));
-                } else {
-                    selectedPaths.add(f.path);
-                    console.log(chalk.green(`   + 📄 ${f.relativePath}`));
-                }
-            }
-
-            // Handle load more or exit pagination
-            if (loadMore && hasMore) {
-                page++;
-            } else {
-                continuePaging = false;
-            }
-        }
-    }
-
-    console.log(chalk.green(`\n✓ Total: ${selectedPaths.size} files selected\n`));
-    return Array.from(selectedPaths);
-}