link.js

// tiddlers
var foo = { name: "foo" };
var bar = { name: "bar" };
var baz = { name: "baz" };
var lorem = { name: "lorem" };
var ipsum = { name: "ipsum" };
var alpha = { name: "alpha" };
var bravo = { name: "bravo" };

// relationships
foo.fields = { "thread.parent": alpha };
bar.fields = { "thread.parent": foo };
baz.fields = { "thread.parent": alpha };
lorem.fields = { "thread.parent": bravo };
ipsum.fields = { "thread.parent": bravo };

var tiddlers = [foo, alpha, bar, lorem, baz, bravo, ipsum];

// generate nested relationship graph from backreferences
// N.B.: Will generate recursive references.
// algorithm by cdent
function generateTree(tiddlers) {
	var threads = [];
	while(tiddlers.length) {
		var node = tiddlers.pop();
		if(node.fields && node.fields["thread.parent"]) {
			var ancestor = node.fields["thread.parent"];
			if(ancestor.descendants) {
				ancestor.descendants.push(node);
			} else {
				ancestor.descendants = [node];
			}
		} else {
			threads.push(node);
		}
	}
	return threads;
}

var tree = generateTree(tiddlers, "thread.parent");
console.log("threads", tree); // XXX: DEBUG

// traverse relationship graph
function traverse(node, level) {
	level = level || 0;
	console.log(level, "traversing", node.name, node);
	var nodes = node.descendants || []; // XXX: fallback hacky?
	for(var i = 0; i < nodes.length; i++) {
		traverse(nodes[i], level + 1);
	}
}

for(var i = 0; i < tree.length; i++) {
	console.log("thread", tree[i]);
	traverse(tree[i]);
}

link.py

from pprint import pprint

foo = {'name': 'foo'}
bar = {'name': 'bar'}
baz = {'name': 'baz'}
mytopic = {'name': 'mytopic'}
myothertopic = {'name': 'myothertopic'}
can = {'name': 'can'}

foo['parent'] = mytopic
bar['parent'] = foo
baz['parent'] = mytopic
can['parent'] = myothertopic

things = [foo, myothertopic, bar, can, baz, mytopic]

tops = []
while things:
    this = things.pop()
    try:
        parent = this['parent']
    except KeyError:
        tops.append(this)
        continue
    try:
        parent['child'].append(this)
    except KeyError:
        parent['child'] = [this]

pprint(tops)

print "####### now traverse"

def traverse(node):
    try:
        children = node['child']
        print 'node ',  node['name']
        print 'kids:'
        for child in children:
            print '\t', child['name']
            traverse(child)
    except KeyError:
        return

for top in tops:
    print 'top:', top['name']
    traverse(top)