Merkle Tree Verifier (javascript, written by Claude Code)

Claude Code wrote this javascript project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Merkle Tree Verifier

Write a program that builds Merkle trees from file collections and uses them to verify data integrity, detect modifications, and efficiently identify which specific files have changed.

FUNCTIONAL REQUIREMENTS:
- Accept a directory path as a command-line argument
- Build a Merkle tree by computing SHA-256 hashes of each file (leaf nodes), then iteratively hashing pairs of child hashes up to a single root hash
- Support two modes via subcommands: build (create tree and save) and verify (check against saved tree)
- build: Compute the Merkle tree and save the tree structure (root hash, intermediate hashes, leaf hashes with file paths) to a JSON manifest file via --output flag (default: merkle_tree.json)
- verify: Load a saved Merkle tree and compare against current file state, efficiently identifying exactly which files were modified, added, or deleted without rehashing unchanged branches
- Display the tree structure visually in the console using ASCII tree formatting showing hash prefixes at each level
- Support configurable hash algorithm via --algorithm flag: SHA-256 (default), SHA-512, SHA3-256
- Support file filtering via --exclude flag with glob patterns to skip certain files
- Compute and display tree statistics: total files (leaf nodes), tree depth, total nodes, root hash, and build time
- Support comparing two Merkle trees via --diff flag: show which subtrees differ between two previously built trees
- Support incremental updates via --update flag: rebuild only changed subtrees rather than the entire tree
- Print verification results to console: root hash match status, list of modified/added/deleted files with their old and new hashes
- If no arguments are given, create a sample directory with 16 files, build the Merkle tree, display the tree structure, then modify 2 files, delete 1, add 1, and run verification to demonstrate efficient change detection
- Handle errors: empty directories, permission denied on files, files modified during tree building, and corrupted manifest files

Create a complete JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

#!/usr/bin/env node
/**
 * Merkle Tree Verifier
 * Builds Merkle trees from files for integrity verification and change detection.
 * Uses crypto-js for hashing and commander for CLI interface.
 */

const fs = require('fs');
const path = require('path');
const CryptoJS = require('crypto-js');
const { Command } = require('commander');

const ALGORITHMS = {
    sha256: (data) => CryptoJS.SHA256(data).toString(),
    sha512: (data) => CryptoJS.SHA512(data).toString(),
    sha3: (data) => CryptoJS.SHA3(data).toString(),
    md5: (data) => CryptoJS.MD5(data).toString(),
};

class MerkleNode {
    constructor(hashValue, left = null, right = null, source = '') {
        this.hashValue = hashValue;
        this.left = left;
        this.right = right;
        this.source = source;
    }

    isLeaf() {
        return this.left === null && this.right === null;
    }

    toJSON() {
        const obj = { hash: this.hashValue };
        if (this.source) obj.source = this.source;
        if (this.left) obj.left = this.left.toJSON();
        if (this.right) obj.right = this.right.toJSON();
        return obj;
    }
}

class MerkleTree {
    constructor(algorithm = 'sha256') {
        if (!ALGORITHMS[algorithm]) {
            throw new Error(`Unsupported algorithm: ${algorithm}`);
        }
        this.algorithm = algorithm;
        this.hashFn = ALGORITHMS[algorithm];
        this.root = null;
        this.leaves = [];
        this.buildTime = 0;
    }

    hashData(data) {
        return this.hashFn(data);
    }

    hashFile(filePath) {
        const content = fs.readFileSync(filePath);
        const wordArray = CryptoJS.lib.WordArray.create(content);
        return this.hashFn(wordArray);
    }

    hashPair(leftHash, rightHash) {
        return this.hashData(leftHash + rightHash);
    }

    buildFromDirectory(dirPath, pattern = null) {
        const files = this.collectFiles(dirPath).sort();
        return this.buildFromFiles(files);
    }

    collectFiles(dirPath) {
        let results = [];
        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
        for (const entry of entries) {
            const fullPath = path.join(dirPath, entry.name);
            if (entry.isDirectory()) {
                results = results.concat(this.collectFiles(fullPath));
            } else if (entry.isFile()) {
                results.push(fullPath);
            }
        }
        return results;
    }

    buildFromFiles(filePaths) {
        const start = Date.now();
        if (filePaths.length === 0) {
            throw new Error('No files provided');
        }

        this.leaves = filePaths.map(fp => {
            const hash = this.hashFile(fp);
            return new MerkleNode(hash, null, null, fp);
        });

        this.root = this._buildTree([...this.leaves]);
        this.buildTime = (Date.now() - start) / 1000;
        return this.root;
    }

    buildFromData(dataBlocks) {
        const start = Date.now();
        this.leaves = dataBlocks.map((block, i) => {
            const hash = this.hashData(block);
            return new MerkleNode(hash, null, null, `block_${i}`);
        });
        this.root = this._buildTree([...this.leaves]);
        this.buildTime = (Date.now() - start) / 1000;
        return this.root;
    }

    _buildTree(nodes) {
        if (nodes.length === 1) return nodes[0];

        if (nodes.length % 2 !== 0) {
            const last = nodes[nodes.length - 1];
            nodes.push(new MerkleNode(last.hashValue, null, null, last.source));
        }

        const parents = [];
        for (let i = 0; i < nodes.length; i += 2) {
            const parentHash = this.hashPair(nodes[i].hashValue, nodes[i + 1].hashValue);
            parents.push(new MerkleNode(parentHash, nodes[i], nodes[i + 1]));
        }

        return this._buildTree(parents);
    }

    getRootHash() {
        if (!this.root) throw new Error('Tree not built');
        return this.root.hashValue;
    }

    generateProof(leafIndex) {
        if (leafIndex < 0 || leafIndex >= this.leaves.length) {
            throw new Error(`Invalid leaf index: ${leafIndex}`);
        }

        const proof = [];
        let nodes = [...this.leaves];
        let idx = leafIndex;

        while (nodes.length > 1) {
            if (nodes.length % 2 !== 0) {
                nodes.push(new MerkleNode(nodes[nodes.length - 1].hashValue));
            }
            const siblingIdx = idx % 2 === 0 ? idx + 1 : idx - 1;
            const direction = idx % 2 === 0 ? 'right' : 'left';
            proof.push({ direction, hash: nodes[siblingIdx].hashValue });

            const nextLevel = [];
            for (let i = 0; i < nodes.length; i += 2) {
                const h = this.hashPair(nodes[i].hashValue, nodes[i + 1].hashValue);
                nextLevel.push(new MerkleNode(h));
            }
            nodes = nextLevel;
            idx = Math.floor(idx / 2);
        }

        return proof;
    }

    verifyProof(leafHash, proof, rootHash) {
        let current = leafHash;
        for (const step of proof) {
            if (step.direction === 'right') {
                current = this.hashPair(current, step.hash);
            } else {
                current = this.hashPair(step.hash, current);
            }
        }
        return current === rootHash;
    }

    detectChanges(otherTree) {
        const changes = {
            rootMatch: false,
            modified: [],
            added: 0,
            removed: 0,
        };

        if (this.root && otherTree.root) {
            changes.rootMatch = this.root.hashValue === otherTree.root.hashValue;
        }

        const minLen = Math.min(this.leaves.length, otherTree.leaves.length);
        for (let i = 0; i < minLen; i++) {
            if (this.leaves[i].hashValue !== otherTree.leaves[i].hashValue) {
                changes.modified.push({
                    index: i,
                    file: this.leaves[i].source,
                    oldHash: this.leaves[i].hashValue.substring(0, 16),
                    newHash: otherTree.leaves[i].hashValue.substring(0, 16),
                });
            }
        }

        changes.added = Math.max(0, otherTree.leaves.length - this.leaves.length);
        changes.removed = Math.max(0, this.leaves.length - otherTree.leaves.length);
        return changes;
    }

    exportJSON(outputPath) {
        if (!this.root) throw new Error('Tree not built');
        const data = {
            algorithm: this.algorithm,
            rootHash: this.root.hashValue,
            leafCount: this.leaves.length,
            buildTimeSeconds: this.buildTime,
            tree: this.root.toJSON(),
        };
        fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
    }
}

// CLI
const program = new Command();
program.name('merkle-tree').description('Merkle Tree Verifier for file integrity').version('1.0.0');

program
    .command('build <directory>')
    .description('Build a Merkle tree from directory files')
    .option('-a, --algorithm <algo>', 'Hash algorithm (sha256|sha512|sha3|md5)', 'sha256')
    .option('-o, --output <file>', 'Export tree to JSON file')
    .action((directory, opts) => {
        const tree = new MerkleTree(opts.algorithm);
        tree.buildFromDirectory(directory);
        console.log(`Files: ${tree.leaves.length}`);
        console.log(`Root hash: ${tree.getRootHash()}`);
        console.log(`Build time: ${tree.buildTime.toFixed(4)}s`);
        if (opts.output) {
            tree.exportJSON(opts.output);
            console.log(`Exported to ${opts.output}`);
        }
    });

program
    .command('verify <directory> <treeFile>')
    .description('Verify directory against saved Merkle tree')
    .action((directory, treeFile) => {
        const saved = JSON.parse(fs.readFileSync(treeFile, 'utf-8'));
        const tree = new MerkleTree(saved.algorithm || 'sha256');
        tree.buildFromDirectory(directory);
        if (tree.getRootHash() === saved.rootHash) {
            console.log('VERIFIED: Directory integrity intact.');
        } else {
            console.error('FAILED: Contents have changed!');
            process.exit(1);
        }
    });

program
    .command('diff <dir1> <dir2>')
    .description('Compare two directories via Merkle trees')
    .option('-a, --algorithm <algo>', 'Hash algorithm', 'sha256')
    .action((dir1, dir2, opts) => {
        const t1 = new MerkleTree(opts.algorithm);
        const t2 = new MerkleTree(opts.algorithm);
        t1.buildFromDirectory(dir1);
        t2.buildFromDirectory(dir2);
        const result = t1.detectChanges(t2);
        console.log(`Root match: ${result.rootMatch}`);
        console.log(`Modified: ${result.modified.length}`);
        console.log(`Added: ${result.added}`);
        console.log(`Removed: ${result.removed}`);
        if (result.modified.length > 0) {
            console.log('Changed files:');
            result.modified.forEach(m => console.log(`  [${m.index}] ${m.file}`));
        }
    });

program.parse(process.argv);

module.exports = { MerkleTree, MerkleNode };

{
  "name": "merkle-tree-verifier",
  "version": "1.0.0",
  "description": "Builds Merkle trees from files for integrity verification and change detection",
  "main": "merkle_tree.js",
  "scripts": {
    "start": "node merkle_tree.js",
    "build": "node merkle_tree.js build",
    "verify": "node merkle_tree.js verify",
    "diff": "node merkle_tree.js diff"
  },
  "dependencies": {
    "crypto-js": "^4.2.0",
    "commander": "^12.0.0"
  }
}

# Merkle Tree Verifier

Builds Merkle trees from files for integrity verification and change detection.

## Dependencies
- **crypto-js** - Cryptographic hashing (SHA-256, SHA-512, SHA-3, MD5)
- **commander** - Command-line interface framework

## Usage

### Build a Merkle tree
```bash
node merkle_tree.js build /path/to/directory --output tree.json
```

### Verify directory integrity
```bash
node merkle_tree.js verify /path/to/directory tree.json
```

### Compare two directories
```bash
node merkle_tree.js diff /path/to/dir1 /path/to/dir2
```

## Installation
```bash
npm install
```