repo-anon 0.2.0 → 1.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,41 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Use Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Run tests with coverage
+      run: npm test
+
+    - name: Upload coverage reports to Codecov
+      uses: codecov/codecov-action@v4
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        file: ./coverage/clover.xml
+        flags: unittests
+        name: codecov-umbrella
+        fail_ci_if_error: false
+
+    - name: Archive code coverage results
+      uses: actions/upload-artifact@v4
+      with:
+        name: code-coverage-report
+        path: coverage/

package/README.md

@@ -1,64 +1 @@
 # repo-anon
-
-A Node.js CLI tool to anonymize and de-anonymize files in a repository based on a `.phrases` configuration file. Perfect for preparing repositories for AI processing while keeping sensitive info, such as company or brand names, protected.
-
-## Features
-
-- **Anonymize**: Replaces sensitive phrases with configured placeholders.
-- **Replacement History**: Writes `.repo-anon-history.json` with ordered per-file replacement events (including counts).
-- **De-anonymize**: Replays replacement history in reverse order, then runs a full phrase-based pass to also restore new placeholder usage added later.
-- **Recursive**: Traverses through all project directories (ignoring `node_modules`, `.git`, etc.).
-- **CI/CD Ready**: Includes GitLab pipeline configuration for publishing to the GitLab package registry.
-
-## Installation
-
-```bash
-npm install -g @your_gitlab_namespace/repo-anon
-```
-
-*(Note: Replace `@your_gitlab_namespace` with your actual GitLab namespace).*
-
-## Usage
-
-1. Create a `.phrases` file in the current working directory:
-
-   ```json
-   {
-     "CompanyA": "ANON_COMPANY_A",
-     "ck": {
-       "placeholder": "bb",
-       "wordReplace": true
-     }
-   }
-   ```
-
-   String values keep the old behavior and replace matches anywhere inside a word.
-   Object values let you opt into whole-word matching with `wordReplace: true`.
-
-2. Run the anonymization command:
-
-   ```bash
-   repo-anon anonymize
-   ```
-
-   This also writes `.repo-anon-history.json` in the working directory.
-
-3. Revert changes (if needed):
-
-   ```bash
-   repo-anon deanonymize
-   ```
-
-   De-anonymization uses the history file first to reverse exact prior replacements in order, then applies phrase-based de-anonymization globally so newly introduced placeholders are also restored.
-
-## Development
-
-- **Tests**: Run unit tests using `npm test`.
-- **Linting**: Lint the project using `npm run lint`.
-
-## CI/CD Deployment
-
-The project includes a `.gitlab-ci.yml` configured to automatically publish new versions to the GitLab package registry when a tag is pushed.
-
----
-Built with ❤️.

package/bin/repo-anon.js

@@ -1,21 +1,203 @@
 #!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const Anonymizer = require('../lib/processor');
 
-const { program } = require('commander');
-const { anonymize, deanonymize } = require('./../lib/processor');
-const { version } = require('../package.json');
+const helpMessage = `
+Anonymization Tool - CLI
 
-program
-  .version(version)
-  .description('Repository Anonymizer CLI');
+Usage:
+  node repo-anon.js <action> [input] [options]
 
-program
-  .command('anonymize')
-  .description('Anonymize project based on .phrases file')
-  .action(anonymize);
+Actions:
+  anonymize: The action to perform (obscure phrases).
+  deanonymize: The action to perform (unobscure phrases).
 
-program
-  .command('deanonymize')
-  .description('De-anonymize project based on .phrases file')
-  .action(deanonymize);
+Arguments:
+  input: The literal text to process OR a file path.
 
-program.parse(process.argv);
+Options:
+  -f, --file <path>: Explicitly specify a single file path to process.
+  -d, --dir <path>: Process all files in a directory.
+  -p, --pattern <glob>: Filter files by pattern (e.g., "*.txt", "**/*.js").
+  -o, --out-dir <path>: Save processed files here (instead of stdout/overwrite).
+  -r, --recursive: Process directories recursively (default with --dir).
+  -c, --config <path>: Path to the .phrases.json file (default: .phrases.json).
+  --overwrite: Overwrite existing files (only with -d or -f).
+
+Examples:
+  node repo-anon.js anonymize -d ./src -p "**/*.js" -o ./anon_src -r
+  node repo-anon.js anonymize "Meeting with Acme Corp"
+  cat document.txt | node repo-anon.js anonymize
+`;
+
+async function readFromStdin() {
+  if (process.stdin.isTTY) return null;
+  const rl = readline.createInterface({ input: process.stdin, terminal: false });
+  const lines = [];
+  for await (const line of rl) lines.push(line);
+  return lines.join('\n');
+}
+
+function isExistingFile(p) {
+  try { return fs.existsSync(p) && fs.lstatSync(p).isFile(); } catch (e) { return false; }
+}
+
+function isExistingDir(p) {
+  try { return fs.existsSync(p) && fs.lstatSync(p).isDirectory(); } catch (e) { return false; }
+}
+
+// Minimal glob-to-regex converter for pattern matching
+function globToRegex(glob) {
+  if (!glob) return null;
+  // Convert glob to regex:
+  // 1. Escape regex special characters (except * which we handle)
+  let re = glob
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape . + ^ $ { } ( ) | [ ] \
+    .replace(/\*\*/g, '___DOUBLE_STAR___')
+    .replace(/\*/g, '[^\\/]*')
+    .replace(/___DOUBLE_STAR___/g, '.*');
+  return new RegExp(`^${re}$`);
+}
+
+function walkSync(dir, fileList = [], recursive = true) {
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    if (fs.statSync(filePath).isDirectory()) {
+      if (recursive) walkSync(filePath, fileList, recursive);
+    } else {
+      fileList.push(filePath);
+    }
+  }
+  return fileList;
+}
+
+async function run() {
+  const args = process.argv.slice(2);
+  if (args.length < 1 || args.includes('-h') || args.includes('--help')) {
+    console.log(helpMessage);
+    return;
+  }
+
+  const action = args[0].toLowerCase();
+  if (action !== 'anonymize' && action !== 'deanonymize') {
+    console.log(`Error: Unknown action: ${action}\n${helpMessage}`);
+    return;
+  }
+
+  // Parse simple flags
+  let explicitFilePath = null;
+  let explicitDirPath = null;
+  let configPath = '.phrases.json';
+  let outDir = null;
+  let pattern = null;
+  let recursive = false;
+  let overwrite = false;
+  let inputArg = null;
+
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '-f' || arg === '--file') {
+      explicitFilePath = args[++i];
+    } else if (arg === '-d' || arg === '--dir') {
+      explicitDirPath = args[++i];
+    } else if (arg === '-c' || arg === '--config') {
+      configPath = args[++i];
+    } else if (arg === '-o' || arg === '--out-dir') {
+      outDir = args[++i];
+    } else if (arg === '-p' || arg === '--pattern') {
+      pattern = args[++i];
+    } else if (arg === '-r' || arg === '--recursive') {
+      recursive = true;
+    } else if (arg === '--overwrite') {
+      overwrite = true;
+    } else if (!inputArg) {
+      inputArg = arg;
+    }
+  }
+
+  const anonymizer = new Anonymizer(configPath);
+  const patternRegex = globToRegex(pattern);
+
+  // Determine what to process
+  if (explicitDirPath || (inputArg && isExistingDir(inputArg))) {
+    const dirToProcess = explicitDirPath || inputArg;
+    const files = walkSync(dirToProcess, [], recursive || !!explicitDirPath);
+    
+    for (const filePath of files) {
+      // Relative path for pattern matching and out-dir structure
+      const relativePath = path.relative(dirToProcess, filePath).replace(/\\/g, '/');
+      
+      if (patternRegex && !patternRegex.test(relativePath) && !patternRegex.test(path.basename(filePath))) {
+        continue;
+      }
+
+      const text = fs.readFileSync(filePath, 'utf8');
+      const result = action === 'anonymize' ? anonymizer.anonymize(text) : anonymizer.deanonymize(text);
+
+      if (outDir) {
+        const targetPath = path.join(outDir, relativePath);
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.writeFileSync(targetPath, result, 'utf8');
+      } else if (overwrite) {
+        fs.writeFileSync(filePath, result, 'utf8');
+      } else {
+        console.log(`--- File: ${filePath} ---`);
+        process.stdout.write(result + '\n');
+      }
+    }
+  } else {
+    // Single file or direct text or stdin
+    let text = '';
+    let isFile = false;
+    let targetPath = explicitFilePath;
+
+    if (explicitFilePath) {
+      if (isExistingFile(explicitFilePath)) {
+        text = fs.readFileSync(explicitFilePath, 'utf8');
+        isFile = true;
+      } else {
+        console.error(`Error: File not found at ${explicitFilePath}`);
+        return;
+      }
+    } else if (inputArg && inputArg !== '-') {
+      if (isExistingFile(inputArg)) {
+        text = fs.readFileSync(inputArg, 'utf8');
+        isFile = true;
+        targetPath = inputArg;
+      } else {
+        text = inputArg;
+      }
+    } else {
+      text = await readFromStdin();
+      if (text === null) {
+        console.log('Error: No input provided and stdin is a terminal.\n' + helpMessage);
+        return;
+      }
+    }
+
+    const result = action === 'anonymize' ? anonymizer.anonymize(text) : anonymizer.deanonymize(text);
+
+    if (isFile && outDir) {
+      const fileName = path.basename(targetPath);
+      const fullOutDir = path.resolve(process.cwd(), outDir);
+      fs.mkdirSync(fullOutDir, { recursive: true });
+      fs.writeFileSync(path.join(fullOutDir, fileName), result, 'utf8');
+    } else if (isFile && overwrite) {
+      fs.writeFileSync(targetPath, result, 'utf8');
+    } else {
+      process.stdout.write(result + '\n');
+    }
+  }
+}
+
+module.exports = { run };
+
+if (require.main === module) {
+  run().catch(err => {
+    console.error(`An unexpected error occurred: ${err.message}`);
+    process.exit(1);
+  });
+}

package/lib/processor.js

@@ -1,212 +1,79 @@
 const fs = require('fs');
 const path = require('path');
 
-const PHRASES_FILE = '.phrases';
-const HISTORY_FILE = '.repo-anon-history.json';
-const WORD_CHAR_CLASS = 'A-Za-z0-9_';
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-function normalizePhrases(phrases) {
-  return Object.entries(phrases).map(([original, config]) => {
-    if (typeof config === 'string') {
-      return { original, placeholder: config, wordReplace: false };
-    }
-
-    return {
-      original,
-      placeholder: config.placeholder,
-      wordReplace: config.wordReplace === true,
-    };
-  });
-}
-
-function loadPhrases() {
-  if (!fs.existsSync(PHRASES_FILE)) {
-    throw new Error('No .phrases file found.');
+class Anonymizer {
+  constructor(configPath = '.phrases.json') {
+    // Normalize path for Windows compatibility
+    this.configPath = path.isAbsolute(configPath) ? configPath : path.resolve(process.cwd(), configPath);
+    this.loadConfig();
   }
-  return JSON.parse(fs.readFileSync(PHRASES_FILE, 'utf8'));
-}
 
-function buildPattern(search, wordReplace) {
-  const escapedSearch = escapeRegExp(search);
-  return wordReplace
-    ? new RegExp(`(^|[^${WORD_CHAR_CLASS}])(${escapedSearch})(?=[^${WORD_CHAR_CLASS}]|$)`, 'g')
-    : new RegExp(escapedSearch, 'g');
-}
-
-function replaceWithCount(content, search, replace, wordReplace, maxReplacements = Number.POSITIVE_INFINITY) {
-  if (!search || !replace || maxReplacements <= 0 || !content.includes(search)) {
-    return { content, count: 0 };
-  }
-
-  const pattern = buildPattern(search, wordReplace);
-  let count = 0;
-
-  const updatedContent = wordReplace
-    ? content.replace(pattern, (match, prefix) => {
-      if (count >= maxReplacements) {
-        return match;
+  loadConfig() {
+    try {
+      if (!fs.existsSync(this.configPath)) {
+        // Fallback: check if the file is in the same directory as this script
+        const fallbackPath = path.resolve(__dirname, path.basename(this.configPath));
+        if (fs.existsSync(fallbackPath)) {
+          this.configPath = fallbackPath;
+        } else {
+          this.mappings = {};
+          return;
+        }
       }
-      count += 1;
-      return `${prefix}${replace}`;
-    })
-    : content.replace(pattern, (match) => {
-      if (count >= maxReplacements) {
-        return match;
-      }
-      count += 1;
-      return replace;
-    });
-
-  return { content: updatedContent, count };
-}
-
-function processContent(content, phrases, reverse = false, options = {}) {
-  let changed = false;
-  let newContent = content;
-  const replacements = [];
-
-  const entries = normalizePhrases(phrases).sort(
-    (leftEntry, rightEntry) => {
-      const left = reverse ? leftEntry.placeholder : leftEntry.original;
-      const right = reverse ? rightEntry.placeholder : rightEntry.original;
-      return right.length - left.length;
-    }
-  );
-
-  for (const { original, placeholder, wordReplace } of entries) {
-    const search = reverse ? placeholder : original;
-    const replace = reverse ? original : placeholder;
-    const result = replaceWithCount(newContent, search, replace, wordReplace);
-
-    if (result.count > 0) {
-      newContent = result.content;
-      changed = true;
-      if (options.trackHistory === true) {
-        replacements.push({
-          search,
-          replace,
-          wordReplace,
-          count: result.count,
-        });
+      const rawData = fs.readFileSync(this.configPath, 'utf8');
+      if (!rawData.trim()) {
+        this.mappings = {};
+        return;
       }
+      const data = JSON.parse(rawData);
+      this.mappings = data.mappings || {};
+    } catch (err) {
+      console.error(`Warning: Could not load config from ${this.configPath}: ${err.message}`);
+      this.mappings = {};
     }
   }
 
-  if (!changed) {
-    return null;
-  }
-
-  if (options.trackHistory === true) {
-    return { content: newContent, replacements };
-  }
-
-  return newContent;
-}
-
-function applyReverseReplacementHistory(content, replacements = []) {
-  let changed = false;
-  let newContent = content;
-
-  for (let index = replacements.length - 1; index >= 0; index -= 1) {
-    const event = replacements[index];
-    const result = replaceWithCount(
-      newContent,
-      event.replace,
-      event.search,
-      event.wordReplace,
-      event.count
-    );
-
-    if (result.count > 0) {
-      newContent = result.content;
-      changed = true;
+  anonymize(text) {
+    if (!text) return text;
+    let result = text;
+    
+    // Sort keys by length descending to match longest phrases first
+    const sortedKeys = Object.keys(this.mappings).sort((a, b) => b.length - a.length);
+    
+    for (const key of sortedKeys) {
+      const escapedKey = escapeRegExp(key);
+      const regex = new RegExp(escapedKey, 'g');
+      result = result.replace(regex, this.mappings[key]);
     }
+    
+    return result;
   }
 
-  return changed ? newContent : null;
-}
-
-function loadHistory() {
-  if (!fs.existsSync(HISTORY_FILE)) {
-    return null;
-  }
-
-  const raw = JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf8'));
-  return raw && typeof raw === 'object' ? raw : null;
-}
-
-function saveHistory(history) {
-  fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2), 'utf8');
-}
-
-async function walk(dir, callback) {
-  const files = fs.readdirSync(dir);
-  for (const file of files) {
-    if (['node_modules', '.git', '.phrases', HISTORY_FILE, 'package.json', 'package-lock.json', 'bin', 'tests', '.gitlab-ci.yml'].includes(file)) continue;
-    const filePath = path.join(dir, file);
-    if (fs.statSync(filePath).isDirectory()) {
-      await walk(filePath, callback);
-    } else {
-      callback(filePath);
+  deanonymize(text) {
+    if (!text) return text;
+    let result = text;
+    
+    // Reverse mappings: placeholder -> original
+    const reverseMappings = Object.entries(this.mappings).reduce((acc, [key, value]) => {
+      acc[value] = key;
+      return acc;
+    }, {});
+    
+    // Sort values (placeholders) by length descending
+    const sortedPlaceholders = Object.keys(reverseMappings).sort((a, b) => b.length - a.length);
+    
+    for (const placeholder of sortedPlaceholders) {
+      const escapedPlaceholder = escapeRegExp(placeholder);
+      const regex = new RegExp(escapedPlaceholder, 'g');
+      result = result.replace(regex, reverseMappings[placeholder]);
     }
+    
+    return result;
   }
 }
 
-async function anonymize() {
-  const phrases = loadPhrases();
-  const history = {
-    version: 1,
-    createdAt: new Date().toISOString(),
-    files: {},
-  };
-
-  walk(process.cwd(), (filePath) => {
-    const content = fs.readFileSync(filePath, 'utf8');
-    const result = processContent(content, phrases, false, { trackHistory: true });
-
-    if (result) {
-      fs.writeFileSync(filePath, result.content, 'utf8');
-      history.files[filePath] = result.replacements;
-      console.log(`Updated: ${filePath}`);
-    }
-  });
-
-  saveHistory(history);
-  console.log(`Saved replacement history to: ${HISTORY_FILE}`);
-}
-
-async function deanonymize() {
-  const phrases = loadPhrases();
-  const history = loadHistory();
-
-  walk(process.cwd(), (filePath) => {
-    const content = fs.readFileSync(filePath, 'utf8');
-
-    let newContent = null;
-    if (history && history.files && Array.isArray(history.files[filePath])) {
-      newContent = applyReverseReplacementHistory(content, history.files[filePath]);
-    }
-
-    const fallbackInput = newContent || content;
-    const fallbackContent = processContent(fallbackInput, phrases, true);
-
-    const finalContent = fallbackContent || newContent;
-    if (finalContent) {
-      fs.writeFileSync(filePath, finalContent, 'utf8');
-      console.log(`Updated: ${filePath}`);
-    }
-  });
-}
-
-module.exports = {
-  anonymize,
-  deanonymize,
-  processContent,
-  replaceWithCount,
-  applyReverseReplacementHistory,
-  HISTORY_FILE,
-};
+module.exports = Anonymizer;

package/package.json

@@ -1,19 +1,32 @@
 {
   "name": "repo-anon",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "description": "CLI tool to anonymize/de-anonymize repositories.",
-  "main": "index.js",
+  "main": "bin/repo-anon.js",
   "bin": {
     "repo-anon": "bin/repo-anon.js"
   },
-  "dependencies": {
-    "commander": "^13.1.0"
-  },
   "scripts": {
-    "test": "jest",
+    "test": "jest --coverage",
     "lint": "eslint .",
     "start": "node bin/repo-anon.js"
   },
+  "jest": {
+    "coverageThreshold": {
+      "global": {
+        "branches": 80,
+        "functions": 80,
+        "lines": 80,
+        "statements": 80
+      }
+    },
+    "coverageReporters": [
+      "text",
+      "lcov",
+      "clover",
+      "cobertura"
+    ]
+  },
   "keywords": [],
   "author": "",
   "license": "ISC",

package/tests/cli.test.js

@@ -0,0 +1,155 @@
+const fs = require('fs');
+const path = require('path');
+const Anonymizer = require('../lib/processor');
+const { run } = require('../bin/repo-anon.js');
+
+// Mock fs and Anonymizer
+jest.mock('fs');
+jest.mock('../lib/processor');
+
+describe('CLI (bin/repo-anon.js)', () => {
+  let originalArgv;
+  let consoleLogSpy;
+  let consoleErrorSpy;
+  let stdoutWriteSpy;
+  let exitSpy;
+
+  beforeEach(() => {
+    originalArgv = process.argv;
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation();
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation();
+    
+    // Reset mocks
+    jest.clearAllMocks();
+    
+    // Default Anonymizer mock behavior
+    Anonymizer.prototype.anonymize.mockImplementation(text => `anon(${text})`);
+    Anonymizer.prototype.deanonymize.mockImplementation(text => `deanon(${text})`);
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+    stdoutWriteSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  const runCLI = async (args) => {
+    process.argv = ['node', 'repo-anon.js', ...args];
+    await run();
+  };
+
+  it('should show help message when no arguments are provided', async () => {
+    await runCLI([]);
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Usage:'));
+  });
+
+  it('should show error for unknown action', async () => {
+    await runCLI(['invalid-action']);
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Error: Unknown action'));
+  });
+
+  it('should anonymize direct text input', async () => {
+    fs.existsSync.mockReturnValue(false); // Not a file
+    await runCLI(['anonymize', 'hello world']);
+    expect(stdoutWriteSpy).toHaveBeenCalledWith('anon(hello world)\n');
+  });
+
+  it('should anonymize a single file', async () => {
+    const filePath = 'test.txt';
+    const fileContent = 'file content';
+    fs.existsSync.mockReturnValue(true);
+    fs.lstatSync.mockReturnValue({ isFile: () => true, isDirectory: () => false });
+    fs.readFileSync.mockReturnValue(fileContent);
+    
+    await runCLI(['anonymize', filePath]);
+    
+    expect(fs.readFileSync).toHaveBeenCalledWith(filePath, 'utf8');
+    expect(stdoutWriteSpy).toHaveBeenCalledWith('anon(file content)\n');
+  });
+
+  it('should anonymize a directory recursively', async () => {
+    const dirPath = 'src';
+    fs.existsSync.mockReturnValue(true);
+    fs.lstatSync.mockImplementation((p) => ({
+      isFile: () => p.endsWith('.js'),
+      isDirectory: () => p === dirPath
+    }));
+    fs.readdirSync.mockReturnValue(['file1.js', 'subdir']);
+    fs.statSync.mockImplementation((p) => ({
+      isDirectory: () => p.endsWith('subdir')
+    }));
+    // Mock second call for subdir
+    fs.readdirSync.mockReturnValueOnce(['file1.js', 'subdir']).mockReturnValueOnce(['file2.js']);
+    fs.readFileSync.mockReturnValue('content');
+
+    await runCLI(['anonymize', '-d', dirPath, '-r']);
+
+    expect(fs.readFileSync).toHaveBeenCalledTimes(2);
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('--- File:'));
+    expect(stdoutWriteSpy).toHaveBeenCalledWith(expect.stringContaining('anon(content)'));
+  });
+
+  it('should overwrite file when --overwrite is used', async () => {
+    const filePath = 'test.txt';
+    fs.existsSync.mockReturnValue(true);
+    fs.lstatSync.mockReturnValue({ isFile: () => true, isDirectory: () => false });
+    fs.readFileSync.mockReturnValue('original');
+    
+    await runCLI(['anonymize', filePath, '--overwrite']);
+    
+    expect(fs.writeFileSync).toHaveBeenCalledWith(filePath, 'anon(original)', 'utf8');
+  });
+
+  it('should save to out-dir when -o is used', async () => {
+    const filePath = 'test.txt';
+    const outDir = 'output';
+    fs.existsSync.mockReturnValue(true);
+    fs.lstatSync.mockReturnValue({ isFile: () => true, isDirectory: () => false });
+    fs.readFileSync.mockReturnValue('original');
+    
+    await runCLI(['anonymize', filePath, '-o', outDir]);
+    
+    expect(fs.mkdirSync).toHaveBeenCalled();
+    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining(path.join(outDir, 'test.txt')), 'anon(original)', 'utf8');
+  });
+
+  it('should filter files by pattern', async () => {
+    const dirPath = 'src';
+    fs.existsSync.mockReturnValue(true);
+    fs.lstatSync.mockImplementation((p) => ({
+      isFile: () => true,
+      isDirectory: () => p === dirPath
+    }));
+    fs.readdirSync.mockReturnValue(['file1.js', 'file2.txt']);
+    fs.statSync.mockReturnValue({ isDirectory: () => false });
+    fs.readFileSync.mockReturnValue('content');
+
+    await runCLI(['anonymize', '-d', dirPath, '-p', '*.js']);
+
+    // Should only process file1.js
+    expect(fs.readFileSync).toHaveBeenCalledTimes(1);
+    expect(fs.readFileSync).toHaveBeenCalledWith(expect.stringContaining('file1.js'), 'utf8');
+  });
+
+  it('should deanonymize text input', async () => {
+    fs.existsSync.mockReturnValue(false);
+    await runCLI(['deanonymize', 'anon(hello)']);
+    expect(stdoutWriteSpy).toHaveBeenCalledWith('deanon(anon(hello))\n');
+  });
+
+  it('should handle explicit file path with --file', async () => {
+    const filePath = 'explicit.txt';
+    fs.existsSync.mockReturnValue(true);
+    fs.lstatSync.mockReturnValue({ isFile: () => true, isDirectory: () => false });
+    fs.readFileSync.mockReturnValue('content');
+    
+    await runCLI(['anonymize', '--file', filePath]);
+    
+    expect(fs.readFileSync).toHaveBeenCalledWith(filePath, 'utf8');
+    expect(stdoutWriteSpy).toHaveBeenCalledWith('anon(content)\n');
+  });
+});

package/tests/processor.test.js

@@ -1,123 +1,129 @@
-const {
-  processContent,
-  applyReverseReplacementHistory,
-} = require('../lib/processor');
-
-describe('repo-anon processor', () => {
-  test('should anonymize content', () => {
-    const phrases = { company: 'anon' };
-    const content = 'my company is here';
-    const expected = 'my anon is here';
-    const result = processContent(content, phrases);
-    expect(result).toBe(expected);
-  });
+const fs = require('fs');
+const path = require('path');
+const Anonymizer = require('../lib/processor');
 
-  test('should deanonymize content', () => {
-    const phrases = { company: 'anon' };
-    const content = 'my anon is here';
-    const expected = 'my company is here';
-    const result = processContent(content, phrases, true);
-    expect(result).toBe(expected);
-  });
+jest.mock('fs');
 
-  test('should replace inside words by default', () => {
-    const phrases = { th: 'BB' };
-    const content = 'th with other';
-    const expected = 'BB wiBB oBBer';
-    const result = processContent(content, phrases);
-    expect(result).toBe(expected);
-  });
+describe('Anonymizer', () => {
+  const mockConfig = {
+    mappings: {
+      'Acme Corp': 'COMPANY_A',
+      'John Doe': 'USER_1',
+      'secret-key-123': 'SECRET_KEY'
+    }
+  };
 
-  test('should only replace standalone words when wordReplace is true', () => {
-    const phrases = {
-      ck: {
-        placeholder: 'bb',
-        wordReplace: true,
-      },
-    };
-    const content = 'ck back sack (ck) ck.';
-    const expected = 'bb back sack (bb) bb.';
-    const result = processContent(content, phrases);
-    expect(result).toBe(expected);
+  beforeEach(() => {
+    jest.clearAllMocks();
   });
 
-  test('should only deanonymize standalone placeholders when wordReplace is true', () => {
-    const phrases = {
-      ck: {
-        placeholder: 'bb',
-        wordReplace: true,
-      },
-    };
-    const content = 'bb babb stubb (bb) bb.';
-    const expected = 'ck babb stubb (ck) ck.';
-    const result = processContent(content, phrases, true);
-    expect(result).toBe(expected);
-  });
+  describe('constructor and loadConfig', () => {
+    it('should load config from default path if it exists', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
+      
+      const anonymizer = new Anonymizer();
+      expect(anonymizer.mappings).toEqual(mockConfig.mappings);
+    });
 
-  test('should return null if no change', () => {
-    const phrases = { company: 'anon' };
-    const content = 'nothing here';
-    const result = processContent(content, phrases);
-    expect(result).toBeNull();
-  });
+    it('should use fallback path if default path does not exist', () => {
+      fs.existsSync.mockImplementation((p) => p.includes('fallback'));
+      fs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
+      
+      // We need to trigger the fallback logic. 
+      // The code checks if configPath exists, if not it tries fallbackPath.
+      fs.existsSync.mockReturnValueOnce(false).mockReturnValueOnce(true);
+      
+      const anonymizer = new Anonymizer('missing.json');
+      expect(anonymizer.mappings).toEqual(mockConfig.mappings);
+    });
+
+    it('should handle empty or missing config file', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('');
+      
+      const anonymizer = new Anonymizer();
+      expect(anonymizer.mappings).toEqual({});
+    });
 
-  test('should track ordered replacements during anonymize', () => {
-    const phrases = {
-      company: 'ANON_COMPANY',
-      project: 'ANON_PROJECT',
-    };
-    const content = 'company project company';
-
-    const result = processContent(content, phrases, false, { trackHistory: true });
-
-    expect(result.content).toBe('ANON_COMPANY ANON_PROJECT ANON_COMPANY');
-    expect(result.replacements).toEqual([
-      {
-        search: 'company',
-        replace: 'ANON_COMPANY',
-        wordReplace: false,
-        count: 2,
-      },
-      {
-        search: 'project',
-        replace: 'ANON_PROJECT',
-        wordReplace: false,
-        count: 1,
-      },
-    ]);
+    it('should handle invalid JSON in config file', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('invalid json');
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+      
+      const anonymizer = new Anonymizer();
+      expect(anonymizer.mappings).toEqual({});
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
   });
 
-  test('should replay replacement history in reverse using recorded counts', () => {
-    const content = 'ANON_COMPANY x ANON_COMPANY ANON_COMPANY';
-    const replacements = [
-      {
-        search: 'company',
-        replace: 'ANON_COMPANY',
-        wordReplace: false,
-        count: 2,
-      },
-    ];
+  describe('anonymize', () => {
+    let anonymizer;
+
+    beforeEach(() => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
+      anonymizer = new Anonymizer();
+    });
 
-    const restored = applyReverseReplacementHistory(content, replacements);
+    it('should return same text if null or empty', () => {
+      expect(anonymizer.anonymize(null)).toBeNull();
+      expect(anonymizer.anonymize('')).toBe('');
+    });
 
-    expect(restored).toBe('company x company ANON_COMPANY');
+    it('should replace phrases with placeholders', () => {
+      const input = 'Welcome to Acme Corp, John Doe!';
+      const expected = 'Welcome to COMPANY_A, USER_1!';
+      expect(anonymizer.anonymize(input)).toBe(expected);
+    });
+
+    it('should handle overlapping phrases by length (longest first)', () => {
+      anonymizer.mappings = {
+        'Acme': 'SHORT',
+        'Acme Corp': 'LONG'
+      };
+      const input = 'Welcome to Acme Corp';
+      expect(anonymizer.anonymize(input)).toBe('Welcome to LONG');
+    });
+
+    it('should escape regex special characters in phrases', () => {
+      anonymizer.mappings = {
+        'user.name': 'USER_NAME'
+      };
+      const input = 'The user.name is here';
+      expect(anonymizer.anonymize(input)).toBe('The USER_NAME is here');
+    });
   });
 
-  test('should support additional deanonymization after history replay', () => {
-    const phrases = { company: 'ANON_COMPANY' };
-    const content = 'ANON_COMPANY x ANON_COMPANY ANON_COMPANY';
-    const replacements = [
-      {
-        search: 'company',
-        replace: 'ANON_COMPANY',
-        wordReplace: false,
-        count: 2,
-      },
-    ];
-
-    const restoredFromHistory = applyReverseReplacementHistory(content, replacements);
-    const fullyRestored = processContent(restoredFromHistory, phrases, true);
-
-    expect(fullyRestored).toBe('company x company company');
+  describe('deanonymize', () => {
+    let anonymizer;
+
+    beforeEach(() => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
+      anonymizer = new Anonymizer();
+    });
+
+    it('should return same text if null or empty', () => {
+      expect(anonymizer.deanonymize(null)).toBeNull();
+      expect(anonymizer.deanonymize('')).toBe('');
+    });
+
+    it('should replace placeholders with original phrases', () => {
+      const input = 'Welcome to COMPANY_A, USER_1!';
+      const expected = 'Welcome to Acme Corp, John Doe!';
+      expect(anonymizer.deanonymize(input)).toBe(expected);
+    });
+
+    it('should handle overlapping placeholders by length', () => {
+      anonymizer.mappings = {
+        'Original': 'PLACEHOLDER',
+        'Something Else': 'PLACEHOLDER_LONG'
+      };
+      const input = 'Testing PLACEHOLDER_LONG and PLACEHOLDER';
+      const expected = 'Testing Something Else and Original';
+      expect(anonymizer.deanonymize(input)).toBe(expected);
+    });
   });
 });