Completed initial groovy implementation.

build.gradle

@@ -2,5 +2,19 @@ apply plugin: "groovy"
 apply plugin: "maven"
 
 group = "com.jdblabs"
-version = "alpa"
+version = "alpha.0"
 
+repositories {
+    mavenLocal()
+    mavenCentral() }
+
+dependencies {
+    compile 'org.codehaus.groovy:groovy-all:2.3.6'
+    compile 'org.slf4j:slf4j-api:1.7.10'
+    compile 'ch.qos.logback:logback-core:1.1.2'
+    compile 'ch.qos.logback:logback-classic:1.1.2'
+	compile 'com.jdbernard:jdb-util:3.5'
+	compile 'commons-codec:commons-codec:1.10'
+
+    testCompile 'junit:junit:4.12'
+}

src/main/groovy/com/jdblabs/file/TreeDiff.groovy

@@ -1,8 +1,153 @@
 package com.jdblabs.file
 
-import com.jdblabs.util.LightOptionParser
+import groovy.io.FileType
+import com.jdbernard.util.LightOptionParser
+import org.apache.commons.codec.digest.DigestUtils
 
 public class TreeDiff {
 
+    public static final String VERSION = "alpha.0";
+
+    public static void main(String[] args) {
+
+        def cli = [
+            'h': [longName: 'help'],
+            'v': [longName: 'version']
+        ]
+
+        def opts = LightOptionParser.parseOptions(cli, args)
+
+        if (opts.h) { /* TODO */ return }
+
+        if (opts.v) { println "JDB Labs TreeDiff v${VERSION}" }
+
+        if (opts.args.size() < 2) {
+            /* TODO: print usage */
+            println "TreeDiff v${VERSION}: exactly two directory paths are required to compare."
+            System.exit(1) }
+
+        File leftRoot = new File(opts.args[0])
+        File rightRoot = new File(opts.args[1])
+
+        if (!leftRoot.exists() || !leftRoot.isDirectory()) {
+            println "TreeDiff v${VERSION}: '${args[0]}' cannot be found or is not a directory"
+            System.exit(2) }
+
+        if (!rightRoot.exists() || !rightRoot.isDirectory()) {
+            println "TreeDiff v${VERSION}: '${args[1]}' cannot be found or is not a directory"
+            System.exit(2) }
+
+        DirAnalysis left = analyzeDir(leftRoot)
+        DirAnalysis right = analyzeDir(rightRoot)
+
+        same(left, right).each {
+            //       012345678
+            println "same:  ${it.relativePath}" }
+
+        samePathDifferentContents(left, right).each {
+            println "contents differ:  $it" }
+
+        sameContentsDifferentPaths(left, right).each {
+            println "paths differ: ${it.left.relativePath} ${it.right.relativePath}" }
+
+        firstSideOnly(left, right).each {
+            println "left only:  ${it.relativePath}" }
+
+        firstSideOnly(right, left).each {
+            println "right only: ${it.relativePath}" }
+    }
+
+    public static List<FileEntry> same(DirAnalysis left, DirAnalysis right) {
+        return left.allEntries.findAll { l ->
+            FileEntry match = right.byRelativePath[l.relativePath]
+            return match != null && l.checksum == match.checksum }
+    }
+
+    public static Set<String> samePathDifferentContents(DirAnalysis left, DirAnalysis right) {
+        return left.allEntries.findAll { l -> 
+            FileEntry match = right.byRelativePath[l.relativePath]
+            return match != null && l.checksum != match.checksum }
+            .collect { it.relativePath } }
+
+    public static List<FileEntryPair> sameContentsDifferentPaths(DirAnalysis left, DirAnalysis right) {
+        return left.allEntries.inject([]) { acc, l ->
+            List<FileEntry> matches = right.byChecksum[l.checksum]
+            if (matches) {
+                acc.addAll(matches.findAll { l.relativePath != it.relativePath }
+                    .collect { r -> new FileEntryPair(left: l, right: r) }) }
+            return acc }.sort { it.left.checksum }
+    }
+
+    public static List<FileEntry> firstSideOnly(DirAnalysis first, DirAnalysis second) {
+        return first.allEntries.findAll {
+            !second.byRelativePath.containsKey(it.relativePath) &&
+            !second.byChecksum.containsKey(it.checksum) } }
+
+    public static DirAnalysis analyzeDir(File root) {
+        DirAnalysis analysis = new DirAnalysis()
+
+        root.eachFileRecurse(FileType.FILES) { file ->
+            FileEntry entry = new FileEntry(
+                file: file,
+                relativePath: getRelativePath(root, file),
+                checksum: file.withInputStream { DigestUtils.md5Hex(it) })
+
+            analysis.allEntries << entry;
+            analysis.byRelativePath[entry.relativePath] = entry
+
+            if (!analysis.byChecksum.containsKey(entry.checksum)) {
+                analysis.byChecksum[entry.checksum] = [] }
+            analysis.byChecksum[entry.checksum] << entry }
+
+        return analysis
+    }
+
+    public static class DirAnalysis {
+        List<FileEntry> allEntries = [];
+        Map<String, FileEntry> byRelativePath = [:]
+        Map<String, List<FileEntry> > byChecksum = [:]
+    }
+
+    public static class FileEntry {
+        File file
+        String relativePath
+        String checksum
+
+        public boolean equals(Object that) {
+            if (that == null) return falase
+            if (!(that instanceof FileEntry)) return false
+
+
+            return this.relativePath == that.relativePath &&
+                   this.checksum == that.checksum; }
+    }
+
+    public static class FileEntryPair {
+        FileEntry left;
+        FileEntry right;
+    }
+
+    /** #### `getRelativePath`
+      * Given a parent path and a child path, assuming the child path is
+      * contained within the parent path, return the relative path from the
+      * parent to the child. */
+    public static String getRelativePath(File parent, File child) {
+        def parentPath = parent.canonicalPath.split("[\\\\/]")
+        def childPath = child.canonicalPath.split("[\\\\/]")
+
+        /// If the parent path is longer it cannot contain the child path and
+        /// we cannot construct a relative path without backtracking.
+        if (parentPath.length > childPath.length) return ""
+
+        /// Compare the parent and child path up until the end of the parent
+        /// path.
+        int b = 0
+        while (b < parentPath.length && parentPath[b] == childPath[b] ) b++;
+
+        /// If we stopped before reaching the end of the parent path it must be
+        /// that the paths do not match. The parent cannot contain the child and
+        /// we cannot build a relative path without backtracking.
+        if (b != parentPath.length) return ""
+        return (['.'] + childPath[b..<childPath.length]).join('/') }
 
 }