repo-anon 0.1.2 → 0.2.0

package/.github/workflows/publish.yml

@@ -3,6 +3,8 @@ name: Publish to NPM
 on:
   release:
     types: [published]
+    # add manual trigger for testing
+  workflow_dispatch:
 
 jobs:
   build:
@@ -13,7 +15,7 @@ jobs:
         with:
           node-version: '20'
           registry-url: 'https://registry.npmjs.org'
-      - run: npm ci
+      - run: npm install
       - run: npm test
       - run: npm publish
         env:

package/README.md

@@ -5,7 +5,8 @@ A Node.js CLI tool to anonymize and de-anonymize files in a repository based on
 ## Features
 
 - **Anonymize**: Replaces sensitive phrases with configured placeholders.
-- **De-anonymize**: Restores original phrases from 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.
 
@@ -23,23 +24,33 @@ npm install -g @your_gitlab_namespace/repo-anon
 
    ```json
    {
-     "CompanyA": "ANON_COMPANY_A", 
-     "BrandX": "ANON_BRAND_X"
+     "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`.

package/lib/processor.js

@@ -2,6 +2,26 @@ 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 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)) {
@@ -10,25 +30,123 @@ function loadPhrases() {
   return JSON.parse(fs.readFileSync(PHRASES_FILE, 'utf8'));
 }
 
-function processContent(content, phrases, reverse = false) {
+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;
+      }
+      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 = [];
 
-  for (const [original, placeholder] of Object.entries(phrases)) {
+  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;
-    if (newContent.includes(search)) {
-      newContent = newContent.split(search).join(replace);
+    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,
+        });
+      }
     }
   }
+
+  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;
+    }
+  }
+
   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', 'package.json', 'package-lock.json', 'bin', 'tests', '.gitlab-ci.yml'].includes(file)) continue;
+    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);
@@ -40,26 +158,55 @@ async function walk(dir, callback) {
 
 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 newContent = processContent(content, phrases);
-    if (newContent) {
-      fs.writeFileSync(filePath, newContent, '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');
-    const newContent = processContent(content, phrases, true);
-    if (newContent) {
-      fs.writeFileSync(filePath, newContent, '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 };
+module.exports = {
+  anonymize,
+  deanonymize,
+  processContent,
+  replaceWithCount,
+  applyReverseReplacementHistory,
+  HISTORY_FILE,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repo-anon",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "CLI tool to anonymize/de-anonymize repositories.",
   "main": "index.js",
   "bin": {
@@ -11,7 +11,8 @@
   },
   "scripts": {
     "test": "jest",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "start": "node bin/repo-anon.js"
   },
   "keywords": [],
   "author": "",

package/tests/processor.test.js

@@ -1,27 +1,123 @@
-const { processContent } = require('../lib/processor');
+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);
-    });
-
-    test('should deanonymize content', () => {
-        const phrases = { "company": "anon" };
-        const content = "my anon is here";
-        const expected = "my company is here";
-        // reverse = true
-        const result = processContent(content, phrases, true);
-        expect(result).toBe(expected);
-    });
-
-    test('should return null if no change', () => {
-        const phrases = { "company": "anon" };
-        const content = "nothing here";
-        const result = processContent(content, phrases);
-        expect(result).toBeNull();
-    });
+  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);
+  });
+
+  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);
+  });
+
+  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);
+  });
+
+  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);
+  });
+
+  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);
+  });
+
+  test('should return null if no change', () => {
+    const phrases = { company: 'anon' };
+    const content = 'nothing here';
+    const result = processContent(content, phrases);
+    expect(result).toBeNull();
+  });
+
+  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,
+      },
+    ]);
+  });
+
+  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,
+      },
+    ];
+
+    const restored = applyReverseReplacementHistory(content, replacements);
+
+    expect(restored).toBe('company x company ANON_COMPANY');
+  });
+
+  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');
+  });
 });