repo-cloak-cli 1.2.1 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repo-cloak-cli",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "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",

package/src/commands/pull.js

@@ -24,6 +24,7 @@ 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';
 
 export async function pull(options = {}) {
     try {
@@ -180,6 +181,8 @@ export async function pull(options = {}) {
             }
         }
 
+        // ...
+
         // Step 3: Get source directory if not already determined
         if (!sourceDir) {
             sourceDir = options.source
@@ -194,8 +197,72 @@ export async function pull(options = {}) {
 
         console.log(chalk.dim(`   Source: ${sourceDir}\n`));
 
-        // Step 4: Select files
-        const selectedFiles = await selectFiles(sourceDir);
+        // Step 4: Select files (Check for Git integration first)
+        let selectedFiles = [];
+        let useGitFiles = false;
+
+        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 (useGit) {
+                const spinner = ora('Scanning changed files...').start();
+                const gitFiles = await getChangedFiles(sourceDir);
+                spinner.stop();
+
+                if (gitFiles.length === 0) {
+                    console.log(chalk.yellow('   No changed or added files found in Git status.'));
+                    const { fallback } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'fallback',
+                            message: 'Do you want to manually select files instead?',
+                            default: true
+                        }
+                    ]);
+
+                    if (!fallback) {
+                        return;
+                    }
+                } else {
+                    // Filter to absolute paths and exist check
+                    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.`));
+
+                        // Let user confirm/deselect git files
+                        const { confirmGitFiles } = 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
+                                }))
+                            }
+                        ]);
+
+                        selectedFiles = confirmGitFiles;
+                        useGitFiles = true;
+                    }
+                }
+            }
+        }
+
+        if (!useGitFiles || selectedFiles.length === 0) {
+            selectedFiles = await selectFiles(sourceDir);
+        }
 
         if (selectedFiles.length === 0) {
             showError('No files selected. Aborting.');

package/src/commands/push.js

@@ -24,10 +24,20 @@ import { getOrCreateSecret, hasSecret, decrypt, getConfigDir } from '../core/cry
 
 export async function push(options = {}) {
     try {
-        // Step 1: Get source (cloaked) directory
-        const cloakedDir = options.source
-            ? resolve(options.source)
-            : await promptBackupFolder();
+        // Step 1: Check if current directory has a mapping (auto-detect)
+        const currentDir = process.cwd();
+        let cloakedDir;
+
+        if (hasMapping(currentDir) && !options.source) {
+            // Running from inside a cloaked directory - use it directly
+            cloakedDir = currentDir;
+            console.log(chalk.cyan('\n   Cloaked directory detected in current folder'));
+        } else {
+            // Ask for the source directory
+            cloakedDir = options.source
+                ? resolve(options.source)
+                : await promptBackupFolder();
+        }
 
         if (!existsSync(cloakedDir)) {
             showError(`Directory does not exist: ${cloakedDir}`);

package/src/core/git.js

@@ -0,0 +1,61 @@
+/**
+ * Git Integration
+ * Utilities to interact with Git repositories
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if a directory is a Git repository
+ * @param {string} dirPath - Directory to check
+ * @returns {boolean} True if .git folder exists
+ */
+export function isGitRepo(dirPath) {
+    return existsSync(join(dirPath, '.git'));
+}
+
+/**
+ * Get list of changed/added/untracked files
+ * @param {string} dirPath - Repository root
+ * @returns {Promise<string[]>} List of relative file paths
+ */
+export async function getChangedFiles(dirPath) {
+    try {
+        // -u option shows individual files in untracked directories
+        const { stdout } = await execAsync('git status --porcelain -u', { cwd: dirPath });
+
+        if (!stdout) return [];
+
+        const files = stdout
+            .split('\n')
+            .filter(line => line.trim() !== '')
+            .map(line => {
+                // Format: "MM file.txt" or "?? file.txt" or "R  old -> new"
+                const status = line.substring(0, 2);
+                let file = line.substring(3).trim();
+
+                // Handle renamed files: "old -> new"
+                if (file.includes(' -> ')) {
+                    file = file.split(' -> ')[1];
+                }
+
+                // Remove quotes if present (git status quotes files with spaces)
+                const cleanFile = file.replace(/^"|"$/g, '');
+
+                return { status, file: cleanFile };
+            })
+            // Filter deleted files (D) as we can't pull them
+            .filter(item => !item.status.includes('D'))
+            .map(item => item.file);
+
+        return files;
+    } catch (error) {
+        // If git command fails, return empty list
+        return [];
+    }
+}

package/tests/git.test.js

@@ -0,0 +1,103 @@
+/**
+ * Git Module Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { isGitRepo, getChangedFiles } from '../src/core/git.js';
+import { existsSync, mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { execSync } from 'child_process';
+
+describe('Git Module', () => {
+    let testDir;
+
+    function initGitRepo(dir) {
+        execSync('git init', { cwd: dir });
+        execSync('git config user.name "Test User"', { cwd: dir });
+        execSync('git config user.email "test@example.com"', { cwd: dir });
+    }
+
+    beforeEach(() => {
+        testDir = join(tmpdir(), `repo-cloak-git-test-${Date.now()}`);
+        mkdirSync(testDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            try {
+                rmSync(testDir, { recursive: true, force: true });
+            } catch (e) {
+                // Ignore cleanup errors
+            }
+        }
+    });
+
+    describe('isGitRepo', () => {
+        it('should return true for git repository', () => {
+            initGitRepo(testDir);
+            expect(isGitRepo(testDir)).toBe(true);
+        });
+
+        it('should return false for non-git directory', () => {
+            expect(isGitRepo(testDir)).toBe(false);
+        });
+    });
+
+    describe('getChangedFiles', () => {
+        it('should return empty list for clean repo', async () => {
+            initGitRepo(testDir);
+            const files = await getChangedFiles(testDir);
+            expect(files).toEqual([]);
+        });
+
+        it('should detect untracked files', async () => {
+            initGitRepo(testDir);
+            writeFileSync(join(testDir, 'newfile.txt'), 'content');
+
+            const files = await getChangedFiles(testDir);
+            expect(files).toContain('newfile.txt');
+        });
+
+        it('should detect modified files', async () => {
+            initGitRepo(testDir);
+            writeFileSync(join(testDir, 'test.txt'), 'initial');
+            execSync('git add test.txt', { cwd: testDir });
+            execSync('git commit -m "initial"', { cwd: testDir });
+
+            writeFileSync(join(testDir, 'test.txt'), 'changed');
+
+            const files = await getChangedFiles(testDir);
+            expect(files).toContain('test.txt');
+        });
+
+        it('should expand untracked directories', async () => {
+            initGitRepo(testDir);
+            const deployDir = join(testDir, 'deploy');
+            mkdirSync(deployDir);
+            writeFileSync(join(deployDir, 'config.yml'), 'config');
+            writeFileSync(join(deployDir, 'script.sh'), 'script');
+
+            // git status --porcelain shows "?? deploy/"
+            // We want ["deploy/config.yml", "deploy/script.sh"]
+
+            const files = await getChangedFiles(testDir);
+            expect(files).toContain('deploy/config.yml'); // Using forward slash for cross-platform expectation in test
+            expect(files).toContain('deploy/script.sh');
+            expect(files).toHaveLength(2);
+        });
+
+        it('should handle renamed files', async () => {
+            initGitRepo(testDir);
+            writeFileSync(join(testDir, 'old.txt'), 'content');
+            execSync('git add old.txt', { cwd: testDir });
+            execSync('git commit -m "initial"', { cwd: testDir });
+
+            execSync('git mv old.txt new.txt', { cwd: testDir });
+
+            const files = await getChangedFiles(testDir);
+            expect(files).toContain('new.txt');
+            expect(files).not.toContain('old.txt');
+        });
+    });
+});