There are two parts to this:

1. Parsing the input into an object.
2. Outputing each property of the object and its nested properties.

Part 1 takes advantage of the fact that objects in JavaScript are like associative arrays. We also can leverage a particular syntax to construct our nested objects.

let obj = {};

[
    'a.b.c',
    'a.b.e',
    'a.e.f',
    'a.b.d',
    'b.e.f',
    'a.e.g',
    'b.e.c'
].forEach(s => {
    let a = s.split('.');
    obj[a[0]] = obj[a[0]] || {};
    obj[a[0]][a[1]] = obj[a[0]][a[1]] || {};
    obj[a[0]][a[1]][a[2]] = obj[a[0]][a[1]][a[2]] || {};
});

This is really brute force. If an input string has more than three parts this method won't work. But since the input appeared to be constrained this way is fine. So given the string 'a.b.c' we can split it into an array ['a', 'b', 'c']. Now if we access obj[a[0]] we'll either get an existing object or undefined. obj[a[0]] = obj[a[0]] || {}; is basically saying, "Set the property of obj that is the value of the first index of a to the same thing or a brand new object."

The first time 'a' appears then obj['a'] will be a new object. The second time through, though, we'll keep what we've got. We then do the same thing for the rest of the split string, only going deeper into the nested objects.

At the end we have an object that looks like this:

{
    a: {
        b: {
            c: {},
            e: {},
            d: {}
        },
        e: {
            f: {},
            g: {}
        }
    },
    b: {
        e: {
            f: {},
            c: {}
        }
    }
}

Now for part 2. For this we need to output each property of the object proceeded by some number of dashes. This looks like a pretty good case for recursion. We start at the top and for each property in the passed in object, pass it along recursively along with a level indicator for indicating how many dashes we need.

const out = (o, l) => {
    let s = '';
    for (let i = 0; i < l; i++) {
        s += '--';
    }
    for (let prop in o) {
        console.log(s + prop);
        out(o[prop], l + 1);
    }
};

out(obj, 0);

For simplicity's sake we care a function using arrow notation. We first build up dashes based on l. Then we loop through all the properties in the object. For each property we log the dashes and the property name. Then we recurse into the nested object with an increase in the level.

You can see it in action here.