                              (mapcat :components) vals set)
 
          components (->> manifest
-                      :components
-                      (filter (comp component-keys :component)))
+                         :components
+                         (filter (comp component-keys :component)))
 
          components-by-id (->> manifest
-                            :components
-                            (map (juxt :component identity))
-                            (into {}))
+                               :components
+                               (map (juxt :component identity))
+                               (into {}))
 
          modules (for [a (->> manifest :modules (filter select-module?))]
                    (merge a

  ([name app-template & args]

   (let [augment-by (->> args
                      (keep (partial re-matches #"\+(.*)") )
                      (map second)    ; take the grouping
                      (map #(split % #"/"))
                      (map (partial apply keyword))
                      set)

         diminish-by (->> args
                       (keep (partial re-matches #"\-(.*)") )
                       (map second)   ; take the grouping
                       (map #(split % #"/"))
                       (map (partial apply keyword))
                       set)

         manifest (load-manifest (io/resource "manifest.edn") name)



               :dependencies
               (->>
                (for [m modules
                      :let [mkey #(if (keyword? %) (make-key (:module m) %)
                                      (apply make-key %))]

                      [k v] (:dependencies m)
                      [n v] (ensure-map v)
                      ]
                  [(mkey k) [n (mkey v)]])
                ;; This call to 'first' should actually check to ensure
                ;; there aren't multiple entries, if there are it means
                ;; we have a conflict - more than one dependency is trying to bind
                (gbf #(into {} (gbf first %)))
                (into {})
                )

               :co-dependencies
               (->>
                (for [m modules
                      :let [mkey #(if (keyword? %) (make-key (:module m) %)
                                      (apply make-key %))]

                      [k v] (:co-dependencies m)
                      [n v] (ensure-map v)
                      ]
                  [(mkey k) [n (mkey v)]])
                ;; This call to 'first' should actually check to ensure
                ;; there aren't multiple entries, if there are it means
                ;; we have a conflict - more than one dependency is trying to bind
                (gbf #(into {} (gbf first %)))
                (into {}))

               :files (concat (get-in manifest [:application-templates app-template :files] [])
                              (mapcat :files modules))}]
