After Effects Script

key-script.js

(function() {
    var log = new File('~/scripts/output.txt');
    log.open("w");
    log.encoding = "UTF-8";

    function writeProperties(object) {
        if (object === null || typeof object === 'undefined') {
            log.writeln("Object has no value");
            return;
        }
        log.writeln("properties of :" +object.toString());
        object.reflect.methods.map(function(item) {log.writeln("   method: " + item.name)});
        object.reflect.properties.map(function(item) {
            try {
                log.writeln("   property: " + item.name + "=" + object[item.name].toString());
            } catch (e) {
                log.writeln("   property: " + item.name + " - " + e.toString());
            }
        });
        log.writeln("----------------------------------------------------------------------------");
    }
    function write(message) {
        log.writeln(message);
    }

    function writeParentTree(property) {
        var parent = property;
        while (parent) {
            log.write(parent.name + " < ");
            parent = parent.parentProperty;
        }
        log.writeln();
    }


    function forEachKeyFrame(property, fn) {
        if (property.matchName === "ADBE Marker") return;
        if (property.numKeys > 0) {
            //write("Processing " + property.numKeys + " keyframes for: " + property.matchName + " - " + property.name);
        }
        for (var keyIndex=1; keyIndex<= property.numKeys; keyIndex++) {
            var keyTime = property.keyTime(keyIndex);
            var keyValue = property.keyValue(keyIndex);
            fn(property, keyIndex, keyTime, keyValue)
            //property.setValueAtTime(keyTime, [100, 500]);
        }
    }

    function forEachProperty(node, fn) {
        //write("Processing node: " + node.matchName + " - " + node.name);
        for (var propertyIndex=1; propertyIndex<=node.numProperties; propertyIndex++) {
            property = node.property(propertyIndex);
            fn(property);
            if (property.propertyType == PropertyType.INDEXED_GROUP || property.propertyType == PropertyType.NAMED_GROUP) 
                forEachProperty(property, fn);
        }
    }

    function findProperties(nodes, filters) {
        var foundProperties = [];
        nodes.map(function(node){
            forEachProperty(node, function(property) {
                if (isFiltersMatched(property, filters)) foundProperties.push(property);
            });
        });
        return foundProperties;
    }

    function isFiltersMatched(property, filters) {
        // last filter must match current property
        // any previous filters must match one of any parent properties
        var lastFilter = filters[filters.length - 1];
        if (!isFilterMatched(property, lastFilter)) return false;
        if (filters.length === 1) return true;

        var matchFound = true;
        var parent = property;
        for (var filterIndex = filters.length -2; filterIndex >= 0; filterIndex--) {
            parent = isFilterMatchAnyParent(parent, filters[filterIndex]);
            if (!parent) {
                matchFound = false;
                break;
            }
        }
        return matchFound;
    }

    function isFilterMatchAnyParent(property, filter) {
        var parents = [];
        var parent = property.parentProperty;
        while(parent) {
            // writeParentTree(parent);
            // writeProperties(filter);
            var matched = isFilterMatched(parent, filter);
            if (matched) return parent;
            parent = parent.parentProperty;
        }
        return null;
    }

    function isFilterMatched(property, filter) {
        if (!filter) return false;
        var noMatch = false;
        for( var key in filter ) {
            if (filter[key] instanceof RegExp) {
                if (!filter[key].test(property[key])) {
                    noMatch = true;
                    break;
                }
            } else if (property[key] !== filter[key]) {
                noMatch = true;
                break;
            }
        }
        return !noMatch;
    }

    function findAllProperties(composite, filters) {
        return findProperties(createArrayOfAllLayers(composite), filters);
    }

    function findOrCreateNullLayer(composite, name) {
        var nullLayer = findLayerByName(composite, name);
        if (nullLayer) return nullLayer;

        nullLayer = composite.layers.addNull();
        nullLayer.name = name;
        return nullLayer;
    }

    function findLayerByName(composite, name) {
        var foundLayer = null;
        createArrayOfAllLayers(composite).map(function(layer) {
            write("layer name: " + layer.name);
            if (layer.name === name) foundLayer = layer; 
        });
        return foundLayer;
    }

    function findOrCreateProperty(parent, type, name) {
        write("find name: " + name);
        var properties = findProperties([parent], [{name: name}]);
        if (properties.length === 1) return properties[0];

        return parent.addProperty(type);
    }

    function findOrCreateSlider(parent, name) {
        var effectsProperty = parent.property("ADBE Effect Parade");
        var sliderControl = findOrCreateProperty(effectsProperty, "ADBE Slider Control", name);
        
        if (sliderControl !== null) {
            sliderControl.name = name;
        }
        return sliderControl.property("ADBE Slider Control-0001");
    }

    function createKeyFrame(property, time, value) {
        var keyIndex = property.addKey(time);
        property.setValueAtKey(keyIndex, value);
        return keyIndex;
    }

    function createArrayOfAllLayers(composite) {
        var layers = [];
        for(var index = 1; index <= composite.numLayers; index++) {
            layers.push(composite.layer(index));
        }
        return layers;
    }


    // --------------------------------------- script code ----------------------------------------------
    if (app.project === null) return;
    var composite = app.project.activeItem;

    if ((composite === null) || !(composite instanceof CompItem)) {
        alert("no composite", "key script");
        return;
    }


    function generateSummedKeyFrames(sourceProperties, computedLayer) {
        sourceProperties.map(function(property) {
            var slider = findOrCreateSlider(computedLayer, "Computed - " + property.name);
            var sum = 0;
            forEachKeyFrame(property, function(property, keyIndex, time, value) {
                createKeyFrame(slider, time, sum += value[0]);
            })
        });
    }

    app.beginUndoGroup("key script");

    var propertyList = findAllProperties(composite, [{name: "Dark Gray Solid 1"}, {name: "Transform"}, {name: /Pos.*/}]);
    generateSummedKeyFrames(propertyList, findOrCreateNullLayer(composite, "Summed Key Frames"));

    app.endUndoGroup();
    log.close();
})();

Simple script used to sum key frame values.
Also with simple library functions to assist collecting effect nodes/properties of interest.