repo-cloak-cli 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repo-cloak-cli",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "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",
@@ -10,7 +10,8 @@
   },
   "scripts": {
     "start": "node bin/repo-cloak.js",
-    "test": "node --test",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "lint": "eslint src/"
   },
   "keywords": [
@@ -43,5 +44,8 @@
     "glob": "^10.3.10",
     "inquirer": "^9.2.12",
     "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.18"
   }
 }

package/src/commands/pull.js

@@ -19,7 +19,7 @@ import { showSuccess, showError, showInfo } from '../ui/banner.js';
 import { getAllFiles } from '../core/scanner.js';
 import { copyFiles } from '../core/copier.js';
 import { createAnonymizer } from '../core/anonymizer.js';
-import { createMapping, saveMapping } from '../core/mapper.js';
+import { createMapping, saveMapping, loadRawMapping, mergeMapping, hasMapping } from '../core/mapper.js';
 
 export async function pull(options = {}) {
     try {
@@ -106,28 +106,49 @@ export async function pull(options = {}) {
             });
         }
 
-        // Step 8: Save mapping file with original->anonymized path tracking
-        const mapping = createMapping({
-            sourceDir,
-            destDir,
-            replacements,
-            files: selectedFiles.map(f => {
-                const originalPath = relative(sourceDir, f);
-                // Apply same anonymization logic used in copier
-                let anonymizedPath = originalPath;
-                for (const { original, replacement } of replacements) {
-                    const regex = new RegExp(original.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
-                    anonymizedPath = anonymizedPath.replace(regex, replacement);
-                }
-                return {
-                    original: originalPath,
-                    cloaked: anonymizedPath
-                };
-            })
+        // Step 8: Prepare new file mappings
+        const newFiles = selectedFiles.map(f => {
+            const originalPath = relative(sourceDir, f);
+            let anonymizedPath = originalPath;
+            for (const { original, replacement } of replacements) {
+                const regex = new RegExp(original.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
+                anonymizedPath = anonymizedPath.replace(regex, replacement);
+            }
+            return {
+                original: originalPath,
+                cloaked: anonymizedPath
+            };
         });
 
+        // Step 9: Check for existing mapping and merge if found
+        const existingMapping = loadRawMapping(destDir);
+        let mapping;
+        let isIncremental = false;
+
+        if (existingMapping) {
+            // Merge with existing
+            mapping = mergeMapping(existingMapping, newFiles);
+            isIncremental = true;
+            console.log(chalk.cyan(`   🔄 Merged with existing mapping (incremental pull)`));
+        } else {
+            // Create new mapping
+            mapping = createMapping({
+                sourceDir,
+                destDir,
+                replacements,
+                files: newFiles
+            });
+        }
+
         const mapPath = saveMapping(destDir, mapping);
-        console.log(chalk.dim(`   📋 Mapping saved: ${mapPath}`));
+
+        if (isIncremental) {
+            const history = mapping.pullHistory || [];
+            const lastPull = history[history.length - 1];
+            console.log(chalk.dim(`   📋 Mapping updated: ${lastPull?.filesAdded || 0} new files added (total: ${mapping.stats?.totalFiles})`));
+        } else {
+            console.log(chalk.dim(`   📋 Mapping saved: ${mapPath}`));
+        }
 
         // Done!
         showSuccess('Extraction complete!');

package/src/core/mapper.js

@@ -177,3 +177,59 @@ export function updateMapping(destDir, updates) {
     writeFileSync(mapPath, JSON.stringify(updated, null, 2), 'utf-8');
     return updated;
 }
+
+/**
+ * Load existing raw mapping (without decryption) for merging
+ */
+export function loadRawMapping(cloakedDir) {
+    const mapPath = join(cloakedDir, MAP_FILENAME);
+
+    if (!existsSync(mapPath)) {
+        return null;
+    }
+
+    try {
+        const content = readFileSync(mapPath, 'utf-8');
+        return JSON.parse(content);
+    } catch (error) {
+        return null;
+    }
+}
+
+/**
+ * Merge new files into existing mapping (for incremental pulls)
+ */
+export function mergeMapping(existingMapping, newFiles) {
+    // Get existing file paths for deduplication
+    const existingPaths = new Set(
+        (existingMapping.files || []).map(f => f.cloaked)
+    );
+
+    // Filter out files that already exist (avoid duplicates)
+    const uniqueNewFiles = newFiles.filter(f => !existingPaths.has(f.cloaked));
+
+    // Merge files
+    const mergedFiles = [
+        ...(existingMapping.files || []),
+        ...uniqueNewFiles
+    ];
+
+    // Track pull history
+    const pullHistory = existingMapping.pullHistory || [];
+    pullHistory.push({
+        timestamp: new Date().toISOString(),
+        filesAdded: uniqueNewFiles.length,
+        totalFiles: mergedFiles.length
+    });
+
+    return {
+        ...existingMapping,
+        files: mergedFiles,
+        pullHistory,
+        stats: {
+            ...existingMapping.stats,
+            totalFiles: mergedFiles.length
+        },
+        updatedAt: new Date().toISOString()
+    };
+}

package/tests/anonymizer.test.js

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

package/tests/copier.test.js

@@ -0,0 +1,94 @@
+/**
+ * Copier Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { copyFile, copyFileWithTransform } from '../src/core/copier.js';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('Copier Module', () => {
+    let testDir;
+    let sourceDir;
+    let destDir;
+
+    beforeEach(() => {
+        testDir = join(tmpdir(), `repo-cloak-copier-test-${Date.now()}`);
+        sourceDir = join(testDir, 'source');
+        destDir = join(testDir, 'dest');
+        mkdirSync(sourceDir, { recursive: true });
+        mkdirSync(destDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+
+    describe('copyFile', () => {
+        it('should copy a file to destination', () => {
+            const sourceFile = join(sourceDir, 'test.txt');
+            const destFile = join(destDir, 'test.txt');
+
+            writeFileSync(sourceFile, 'Hello World');
+            copyFile(sourceFile, destFile);
+
+            expect(existsSync(destFile)).toBe(true);
+            expect(readFileSync(destFile, 'utf-8')).toBe('Hello World');
+        });
+
+        it('should create nested directories', () => {
+            const sourceFile = join(sourceDir, 'test.txt');
+            const destFile = join(destDir, 'nested', 'deep', 'test.txt');
+
+            writeFileSync(sourceFile, 'Content');
+            copyFile(sourceFile, destFile);
+
+            expect(existsSync(destFile)).toBe(true);
+        });
+    });
+
+    describe('copyFileWithTransform', () => {
+        it('should transform content during copy', () => {
+            const sourceFile = join(sourceDir, 'code.js');
+            const destFile = join(destDir, 'code.js');
+
+            writeFileSync(sourceFile, 'const company = "Cuviva";');
+
+            const transform = (content) => content.replace(/Cuviva/g, 'ABCCompany');
+            const result = copyFileWithTransform(sourceFile, destFile, transform);
+
+            expect(result.transformed).toBe(true);
+            expect(readFileSync(destFile, 'utf-8')).toBe('const company = "ABCCompany";');
+        });
+
+        it('should report no transformation when content unchanged', () => {
+            const sourceFile = join(sourceDir, 'code.js');
+            const destFile = join(destDir, 'code.js');
+
+            writeFileSync(sourceFile, 'const x = 1;');
+
+            const transform = (content) => content.replace(/Cuviva/g, 'ABCCompany');
+            const result = copyFileWithTransform(sourceFile, destFile, transform);
+
+            expect(result.transformed).toBe(false);
+        });
+
+        it('should handle binary files by copying as-is', () => {
+            const sourceFile = join(sourceDir, 'image.png');
+            const destFile = join(destDir, 'image.png');
+
+            // Create a simple binary-like file
+            const buffer = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x00]);
+            writeFileSync(sourceFile, buffer);
+
+            const transform = (content) => content.replace(/test/g, 'replaced');
+            const result = copyFileWithTransform(sourceFile, destFile, transform);
+
+            expect(result.transformed).toBe(false);
+            expect(existsSync(destFile)).toBe(true);
+        });
+    });
+});

package/tests/crypto.test.js

@@ -0,0 +1,106 @@
+/**
+ * Crypto Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { encrypt, decrypt, encryptReplacements, decryptReplacements } from '../src/core/crypto.js';
+import { existsSync, rmSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+describe('Crypto Module', () => {
+    const testSecret = 'test-secret-key-for-unit-tests-1234567890';
+
+    describe('encrypt/decrypt', () => {
+        it('should encrypt and decrypt a string', () => {
+            const original = 'Hello World';
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, testSecret);
+
+            expect(decrypted).toBe(original);
+        });
+
+        it('should produce different encrypted output each time (random IV)', () => {
+            const original = 'Same input';
+            const encrypted1 = encrypt(original, testSecret);
+            const encrypted2 = encrypt(original, testSecret);
+
+            expect(encrypted1).not.toBe(encrypted2);
+        });
+
+        it('should return null for wrong secret', () => {
+            const original = 'Secret message';
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, 'wrong-secret');
+
+            expect(decrypted).toBeNull();
+        });
+
+        it('should handle special characters', () => {
+            const original = 'Special: @#$%^&*()_+ 日本語 🎭';
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, testSecret);
+
+            expect(decrypted).toBe(original);
+        });
+
+        it('should handle empty string or return null for empty', () => {
+            const original = '';
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, testSecret);
+
+            // Empty string may return empty or null depending on cipher
+            expect(decrypted === '' || decrypted === null).toBe(true);
+        });
+
+        it('should handle long strings', () => {
+            const original = 'A'.repeat(10000);
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, testSecret);
+
+            expect(decrypted).toBe(original);
+        });
+    });
+
+    describe('encryptReplacements/decryptReplacements', () => {
+        it('should encrypt only the original field', () => {
+            const replacements = [
+                { original: 'Cuviva', replacement: 'ABCCompany' },
+                { original: 'Secret', replacement: 'Public' }
+            ];
+
+            const encrypted = encryptReplacements(replacements, testSecret);
+
+            // Replacement should still be visible
+            expect(encrypted[0].replacement).toBe('ABCCompany');
+            expect(encrypted[1].replacement).toBe('Public');
+
+            // Original should be encrypted (contains colons from format)
+            expect(encrypted[0].original).toContain(':');
+            expect(encrypted[0].encrypted).toBe(true);
+        });
+
+        it('should decrypt back to original', () => {
+            const replacements = [
+                { original: 'Cuviva', replacement: 'ABCCompany' }
+            ];
+
+            const encrypted = encryptReplacements(replacements, testSecret);
+            const decrypted = decryptReplacements(encrypted, testSecret);
+
+            expect(decrypted[0].original).toBe('Cuviva');
+            expect(decrypted[0].replacement).toBe('ABCCompany');
+        });
+
+        it('should mark failed decryptions', () => {
+            const replacements = [
+                { original: 'Test', replacement: 'Demo' }
+            ];
+
+            const encrypted = encryptReplacements(replacements, testSecret);
+            const decrypted = decryptReplacements(encrypted, 'wrong-secret');
+
+            expect(decrypted[0].decryptFailed).toBe(true);
+        });
+    });
+});

package/tests/mapper.test.js

@@ -0,0 +1,166 @@
+/**
+ * Mapper Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+    createMapping,
+    saveMapping,
+    loadRawMapping,
+    mergeMapping,
+    hasMapping
+} from '../src/core/mapper.js';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('Mapper Module', () => {
+    let testDir;
+
+    beforeEach(() => {
+        testDir = join(tmpdir(), `repo-cloak-test-${Date.now()}`);
+        mkdirSync(testDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+
+    describe('createMapping', () => {
+        it('should create a valid mapping object', () => {
+            const mapping = createMapping({
+                sourceDir: '/path/to/source',
+                destDir: '/path/to/dest',
+                replacements: [{ original: 'Test', replacement: 'Demo' }],
+                files: [{ original: 'file.js', cloaked: 'file.js' }]
+            });
+
+            expect(mapping.version).toBe('1.1.0');
+            expect(mapping.tool).toBe('repo-cloak');
+            expect(mapping.encrypted).toBe(true);
+            expect(mapping.files).toHaveLength(1);
+            expect(mapping.stats.totalFiles).toBe(1);
+        });
+
+        it('should encrypt sensitive data', () => {
+            const mapping = createMapping({
+                sourceDir: '/secret/path',
+                destDir: '/dest/path',
+                replacements: [{ original: 'SecretWord', replacement: 'Public' }],
+                files: [{ original: 'secret.js', cloaked: 'public.js' }]
+            });
+
+            // Source path should be encrypted (contains :)
+            expect(mapping.source.path).toContain(':');
+            // Replacements original should be encrypted
+            expect(mapping.replacements[0].original).toContain(':');
+            expect(mapping.replacements[0].encrypted).toBe(true);
+        });
+    });
+
+    describe('saveMapping / loadRawMapping', () => {
+        it('should save and load mapping file', () => {
+            const mapping = {
+                version: '1.0.0',
+                files: [{ original: 'a.js', cloaked: 'b.js' }]
+            };
+
+            saveMapping(testDir, mapping);
+
+            expect(hasMapping(testDir)).toBe(true);
+
+            const loaded = loadRawMapping(testDir);
+            expect(loaded.version).toBe('1.0.0');
+            expect(loaded.files).toHaveLength(1);
+        });
+
+        it('should return null for non-existent mapping', () => {
+            const loaded = loadRawMapping('/non/existent/path');
+            expect(loaded).toBeNull();
+        });
+    });
+
+    describe('hasMapping', () => {
+        it('should return true when mapping exists', () => {
+            writeFileSync(join(testDir, '.repo-cloak-map.json'), '{}');
+            expect(hasMapping(testDir)).toBe(true);
+        });
+
+        it('should return false when mapping does not exist', () => {
+            expect(hasMapping(testDir)).toBe(false);
+        });
+    });
+
+    describe('mergeMapping', () => {
+        it('should merge new files with existing mapping', () => {
+            const existing = {
+                version: '1.0.0',
+                files: [
+                    { original: 'a.js', cloaked: 'a.js' },
+                    { original: 'b.js', cloaked: 'b.js' }
+                ],
+                stats: { totalFiles: 2 }
+            };
+
+            const newFiles = [
+                { original: 'c.js', cloaked: 'c.js' },
+                { original: 'd.js', cloaked: 'd.js' }
+            ];
+
+            const merged = mergeMapping(existing, newFiles);
+
+            expect(merged.files).toHaveLength(4);
+            expect(merged.stats.totalFiles).toBe(4);
+        });
+
+        it('should avoid duplicate files', () => {
+            const existing = {
+                version: '1.0.0',
+                files: [
+                    { original: 'a.js', cloaked: 'a.js' },
+                    { original: 'b.js', cloaked: 'b.js' }
+                ],
+                stats: { totalFiles: 2 }
+            };
+
+            const newFiles = [
+                { original: 'b.js', cloaked: 'b.js' },  // Duplicate
+                { original: 'c.js', cloaked: 'c.js' }   // New
+            ];
+
+            const merged = mergeMapping(existing, newFiles);
+
+            expect(merged.files).toHaveLength(3); // Not 4
+            expect(merged.stats.totalFiles).toBe(3);
+        });
+
+        it('should track pull history', () => {
+            const existing = {
+                version: '1.0.0',
+                files: [],
+                stats: { totalFiles: 0 }
+            };
+
+            const merged = mergeMapping(existing, [{ original: 'a.js', cloaked: 'a.js' }]);
+
+            expect(merged.pullHistory).toHaveLength(1);
+            expect(merged.pullHistory[0].filesAdded).toBe(1);
+            expect(merged.pullHistory[0].timestamp).toBeDefined();
+        });
+
+        it('should append to existing pull history', () => {
+            const existing = {
+                version: '1.0.0',
+                files: [{ original: 'a.js', cloaked: 'a.js' }],
+                stats: { totalFiles: 1 },
+                pullHistory: [{ timestamp: '2024-01-01', filesAdded: 1, totalFiles: 1 }]
+            };
+
+            const merged = mergeMapping(existing, [{ original: 'b.js', cloaked: 'b.js' }]);
+
+            expect(merged.pullHistory).toHaveLength(2);
+        });
+    });
+});

package/tests/scanner.test.js

@@ -0,0 +1,100 @@
+/**
+ * Scanner Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { getAllFiles, isBinaryFile } from '../src/core/scanner.js';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('Scanner Module', () => {
+    let testDir;
+
+    beforeEach(() => {
+        testDir = join(tmpdir(), `repo-cloak-scanner-test-${Date.now()}`);
+        mkdirSync(testDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+
+    describe('getAllFiles', () => {
+        it('should find all files in directory', () => {
+            writeFileSync(join(testDir, 'a.js'), 'content');
+            writeFileSync(join(testDir, 'b.js'), 'content');
+
+            const files = getAllFiles(testDir);
+
+            expect(files).toHaveLength(2);
+        });
+
+        it('should find files in nested directories', () => {
+            const nestedDir = join(testDir, 'src', 'components');
+            mkdirSync(nestedDir, { recursive: true });
+
+            writeFileSync(join(testDir, 'index.js'), 'content');
+            writeFileSync(join(nestedDir, 'Button.js'), 'content');
+
+            const files = getAllFiles(testDir);
+
+            expect(files).toHaveLength(2);
+        });
+
+        it('should ignore node_modules', () => {
+            const nodeModules = join(testDir, 'node_modules', 'package');
+            mkdirSync(nodeModules, { recursive: true });
+
+            writeFileSync(join(testDir, 'index.js'), 'content');
+            writeFileSync(join(nodeModules, 'index.js'), 'content');
+
+            const files = getAllFiles(testDir);
+
+            expect(files).toHaveLength(1);
+        });
+
+        it('should ignore .git directories', () => {
+            const gitDir = join(testDir, '.git', 'objects');
+            mkdirSync(gitDir, { recursive: true });
+
+            writeFileSync(join(testDir, 'index.js'), 'content');
+            writeFileSync(join(gitDir, 'abc123'), 'content');
+
+            const files = getAllFiles(testDir);
+
+            expect(files).toHaveLength(1);
+        });
+
+        it('should return empty array for empty directory', () => {
+            const files = getAllFiles(testDir);
+            expect(files).toHaveLength(0);
+        });
+    });
+
+    describe('isBinaryFile', () => {
+        it('should detect common binary extensions', () => {
+            expect(isBinaryFile('image.png')).toBe(true);
+            expect(isBinaryFile('image.jpg')).toBe(true);
+            expect(isBinaryFile('archive.zip')).toBe(true);
+            expect(isBinaryFile('doc.pdf')).toBe(true);
+            expect(isBinaryFile('lib.dll')).toBe(true);
+            expect(isBinaryFile('app.exe')).toBe(true);
+        });
+
+        it('should detect text files', () => {
+            expect(isBinaryFile('code.js')).toBe(false);
+            expect(isBinaryFile('style.css')).toBe(false);
+            expect(isBinaryFile('data.json')).toBe(false);
+            expect(isBinaryFile('README.md')).toBe(false);
+            expect(isBinaryFile('code.ts')).toBe(false);
+        });
+
+        it('should handle paths with directories', () => {
+            expect(isBinaryFile('/path/to/image.png')).toBe(true);
+            expect(isBinaryFile('src/components/Button.js')).toBe(false);
+        });
+    });
+});