diff --git a/.travis.yml b/.travis.yml
index 3d5193d..0a42c0e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -17,7 +17,7 @@
 # in the vendor directory. We don't need to test all dependent packages.
 # Only testing this project.
 script:
-  - GO15VENDOREXPERIMENT=1 go test -v . ./cmd ./gb ./util ./cfg
+  - GO15VENDOREXPERIMENT=1 make test
 
 notifications:
   irc: "irc.freenode.net#masterminds"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index dd05f1b..353ad8b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# Release 0.9.0 (xxxx-xx-xx)
+
+- Refactored Glide
+  - Many features broken out into packages. All but `action/` can be
+    used as libraries.
+  - Support for GPM Godeps-Git has been removed
+  - Cookoo is not used anymore
+  - The `action/` package replaces `cmd/`
+
 # Release 0.8.3 (2015-12-30)
 
 - Issue #198: Instead of stopping `glide install` for a hash failures providing
@@ -19,10 +28,10 @@
 - Fixed #169: cookoo git url has auth info. Makes glide unbuildable for
   environments not setup for GitHub.
 - Fixed #180: the hash in the glide.lock file was not being properly calculated.
-- Fixed #174: glide get was causing an error when the flad --updated-vendored
+- Fixed #174: glide get was causing an error when the flag --updated-vendored
   was being used.
 - Fixed #175: glide get when the GOPATH isn't setup properly could end up in
-  an infinate loop.
+  an infinite loop.
 
 # Release 0.8.1 (2015-12-15)
 
diff --git a/Makefile b/Makefile
index 5d31ee0..7adc280 100644
--- a/Makefile
+++ b/Makefile
@@ -9,7 +9,7 @@
 	install -m 755 ./glide ${DESTDIR}/usr/local/bin/glide
 
 test:
-	go test . ./cmd ./gb
+	go test . ./gb ./path ./action ./tree ./util ./godep ./gpm ./cfg ./dependency ./importer ./msg ./repo
 
 clean:
 	rm -f ./glide.test
@@ -18,7 +18,6 @@
 
 bootstrap:
 	mkdir ./vendor
-	git clone https://github.com/Masterminds/cookoo vendor/github.com/Masterminds/cookoo
 	git clone https://github.com/Masterminds/vcs vendor/github.com/Masterminds/vcs
 	git clone https://gopkg.in/yaml.v2 vendor/gopkg.in/yaml.v2
 	git clone https://github.com/codegangsta/cli vendor/github.com/codegangsta/cli
diff --git a/cmd/about.go b/action/about.go
similarity index 80%
rename from cmd/about.go
rename to action/about.go
index a736f89..e546b6a 100644
--- a/cmd/about.go
+++ b/action/about.go
@@ -1,17 +1,9 @@
-// Package cmd provides re-usable commands for Glide.
-package cmd
+package action
 
-import (
-	"fmt"
+import "github.com/Masterminds/glide/msg"
 
-	"github.com/Masterminds/cookoo"
-)
-
-// About information for the CLI
-func About(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-
-	about := `
-Glide: The Lightweight Vendor Package Manager. Manage your vendor and vendored
+const aboutMessage = `
+Glide: Vendor Package Management for Go. Manage your vendor and vendored
 packages with ease.
 
 Name:
@@ -45,6 +37,7 @@
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     THE SOFTWARE.`
 
-	fmt.Println(about)
-	return true, nil
+// About prints information about Glide.
+func About() {
+	msg.Puts(aboutMessage)
 }
diff --git a/action/about_test.go b/action/about_test.go
new file mode 100644
index 0000000..40d6fc8
--- /dev/null
+++ b/action/about_test.go
@@ -0,0 +1,21 @@
+package action
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/Masterminds/glide/msg"
+)
+
+func TestAbout(t *testing.T) {
+	var buf bytes.Buffer
+	old := msg.Default.Stdout
+	msg.Default.Stdout = &buf
+	About()
+
+	if buf.Len() < len(aboutMessage) {
+		t.Errorf("expected this to match aboutMessage: %q", buf.String())
+	}
+
+	msg.Default.Stdout = old
+}
diff --git a/action/create.go b/action/create.go
new file mode 100644
index 0000000..d08857d
--- /dev/null
+++ b/action/create.go
@@ -0,0 +1,183 @@
+package action
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/dependency"
+	"github.com/Masterminds/glide/gb"
+	"github.com/Masterminds/glide/godep"
+	"github.com/Masterminds/glide/gpm"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/glide/util"
+)
+
+// Create creates/initializes a new Glide repository.
+//
+// This will fail if a glide.yaml already exists.
+//
+// By default, this will scan the present source code directory for dependencies.
+//
+// If skipImport is set to true, this will not attempt to import from an existing
+// GPM, Godep, or GB project if one should exist. However, it will still attempt
+// to read the local source to determine required packages.
+func Create(base string, skipImport bool) {
+	glidefile := gpath.GlideFile
+	// Guard against overwrites.
+	guardYAML(glidefile)
+
+	// Guess deps
+	conf := guessDeps(base, skipImport)
+	// Write YAML
+	if err := conf.WriteFile(glidefile); err != nil {
+		msg.Die("Could not save %s: %s", glidefile, err)
+	}
+}
+
+// guardYAML fails if the given file already exists.
+//
+// This prevents an important file from being overwritten.
+func guardYAML(filename string) {
+	if _, err := os.Stat(filename); err == nil {
+		msg.Die("Cowardly refusing to overwrite existing YAML.")
+	}
+}
+
+// guessDeps attempts to resolve all of the dependencies for a given project.
+//
+// base is the directory to start with.
+// skipImport will skip running the automatic imports.
+//
+// FIXME: This function is likely a one-off that has a more standard alternative.
+// It's also long and could use a refactor.
+func guessDeps(base string, skipImport bool) *cfg.Config {
+	buildContext, err := util.GetBuildContext()
+	if err != nil {
+		msg.Die("Failed to build an import context: %s", err)
+	}
+	name := buildContext.PackageName(base)
+
+	msg.Info("Generating a YAML configuration file and guessing the dependencies")
+
+	config := new(cfg.Config)
+
+	// Get the name of the top level package
+	config.Name = name
+
+	// Import by looking at other package managers and looking over the
+	// entire directory structure.
+
+	// Attempt to import from other package managers.
+	if !skipImport {
+		msg.Info("Attempting to import from other package managers (use --skip-import to skip)")
+		deps := []*cfg.Dependency{}
+		absBase, err := filepath.Abs(base)
+		if err != nil {
+			msg.Die("Failed to resolve location of %s: %s", base, err)
+		}
+
+		if d, ok := guessImportGodep(absBase); ok {
+			msg.Info("Importing Godep configuration")
+			msg.Warn("Godep uses commit id versions. Consider using Semantic Versions with Glide")
+			deps = d
+		} else if d, ok := guessImportGPM(absBase); ok {
+			msg.Info("Importing GPM configuration")
+			deps = d
+		} else if d, ok := guessImportGB(absBase); ok {
+			msg.Info("Importing GB configuration")
+			deps = d
+		}
+
+		for _, i := range deps {
+			msg.Info("Found imported reference to %s\n", i.Name)
+			config.Imports = append(config.Imports, i)
+		}
+	}
+
+	// Resolve dependencies by looking at the tree.
+	r, err := dependency.NewResolver(base)
+	if err != nil {
+		msg.Die("Error creating a dependency resolver: %s", err)
+	}
+
+	h := &dependency.DefaultMissingPackageHandler{Missing: []string{}, Gopath: []string{}}
+	r.Handler = h
+
+	sortable, err := r.ResolveLocal(false)
+	if err != nil {
+		msg.Die("Error resolving local dependencies: %s", err)
+	}
+
+	sort.Strings(sortable)
+
+	vpath := r.VendorDir
+	if !strings.HasSuffix(vpath, "/") {
+		vpath = vpath + string(os.PathSeparator)
+	}
+
+	for _, pa := range sortable {
+		n := strings.TrimPrefix(pa, vpath)
+		root := util.GetRootFromPackage(n)
+
+		if !config.HasDependency(root) {
+			msg.Info("Found reference to %s\n", n)
+			d := &cfg.Dependency{
+				Name: root,
+			}
+			subpkg := strings.TrimPrefix(n, root)
+			if len(subpkg) > 0 && subpkg != "/" {
+				d.Subpackages = []string{subpkg}
+			}
+			config.Imports = append(config.Imports, d)
+		} else {
+			subpkg := strings.TrimPrefix(n, root)
+			if len(subpkg) > 0 && subpkg != "/" {
+				subpkg = strings.TrimPrefix(subpkg, "/")
+				d := config.Imports.Get(root)
+				f := false
+				for _, v := range d.Subpackages {
+					if v == subpkg {
+						f = true
+					}
+				}
+				if !f {
+					msg.Info("Adding sub-package %s to %s\n", subpkg, root)
+					d.Subpackages = append(d.Subpackages, subpkg)
+				}
+			}
+		}
+	}
+
+	return config
+}
+
+func guessImportGodep(dir string) ([]*cfg.Dependency, bool) {
+	d, err := godep.Parse(dir)
+	if err != nil || len(d) == 0 {
+		return []*cfg.Dependency{}, false
+	}
+
+	return d, true
+}
+
+func guessImportGPM(dir string) ([]*cfg.Dependency, bool) {
+	d, err := gpm.Parse(dir)
+	if err != nil || len(d) == 0 {
+		return []*cfg.Dependency{}, false
+	}
+
+	return d, true
+}
+
+func guessImportGB(dir string) ([]*cfg.Dependency, bool) {
+	d, err := gb.Parse(dir)
+	if err != nil || len(d) == 0 {
+		return []*cfg.Dependency{}, false
+	}
+
+	return d, true
+}
diff --git a/action/debug.go b/action/debug.go
new file mode 100644
index 0000000..7b8eea6
--- /dev/null
+++ b/action/debug.go
@@ -0,0 +1,20 @@
+package action
+
+import (
+	"github.com/Masterminds/glide/msg"
+)
+
+// Debug sets the debugging flags across components.
+func Debug(on bool) {
+	msg.Default.IsDebugging = on
+}
+
+// Quiet sets the quiet flags across components.
+func Quiet(on bool) {
+	msg.Default.Quiet = on
+}
+
+// NoColor sets the color flags.
+func NoColor(on bool) {
+	msg.Default.NoColor = on
+}
diff --git a/action/doc.go b/action/doc.go
new file mode 100644
index 0000000..992faf6
--- /dev/null
+++ b/action/doc.go
@@ -0,0 +1,14 @@
+/* Package action provides implementations for every Glide command.
+
+This is not a general-purpose library. It is the main flow controller for Glide.
+
+The main glide package acts as a Facade, with this package providing the
+implementation. This package should know nothing of the command line flags or
+runtime characteristics. However, this package is allowed to control the flow
+of the application, including termination. So actions may call `msg.Die()` to
+immediately stop execution of the program.
+
+In general, actions are not required to function as library functions, nor as
+concurrency-safe functions.
+*/
+package action
diff --git a/action/ensure.go b/action/ensure.go
new file mode 100644
index 0000000..af62dd1
--- /dev/null
+++ b/action/ensure.go
@@ -0,0 +1,97 @@
+package action
+
+import (
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+)
+
+// EnsureConfig loads and returns a config file.
+//
+// Any error will cause an immediate exit, with an error printed to Stderr.
+func EnsureConfig() *cfg.Config {
+	yamlpath, err := gpath.Glide()
+	if err != nil {
+		msg.ExitCode(2)
+		msg.Die("Failed to find %s file in directory tree: %s", gpath.GlideFile, err)
+	}
+
+	yml, err := ioutil.ReadFile(yamlpath)
+	if err != nil {
+		msg.ExitCode(2)
+		msg.Die("Failed to load %s: %s", yamlpath, err)
+	}
+	conf, err := cfg.ConfigFromYaml(yml)
+	if err != nil {
+		msg.ExitCode(3)
+		msg.Die("Failed to parse %s: %s", yamlpath, err)
+	}
+
+	return conf
+}
+
+func EnsureCacheDir() {
+	msg.Warn("ensure.go: ensureCacheDir is not implemented.")
+}
+
+// EnsureGoVendor ensures that the Go version is correct.
+func EnsureGoVendor() {
+	// 6l was removed in 1.5, when vendoring was introduced.
+	cmd := exec.Command("go", "tool", "6l")
+	if _, err := cmd.CombinedOutput(); err == nil {
+		msg.Warn("You must install the Go 1.5 or greater toolchain to work with Glide.\n")
+		os.Exit(1)
+	}
+	if os.Getenv("GO15VENDOREXPERIMENT") != "1" {
+		msg.Warn("To use Glide, you must set GO15VENDOREXPERIMENT=1\n")
+		os.Exit(1)
+	}
+
+	// Verify the setup isn't for the old version of glide. That is, this is
+	// no longer assuming the _vendor directory as the GOPATH. Inform of
+	// the change.
+	if _, err := os.Stat("_vendor/"); err == nil {
+		msg.Warn(`Your setup appears to be for the previous version of Glide.
+Previously, vendor packages were stored in _vendor/src/ and
+_vendor was set as your GOPATH. As of Go 1.5 the go tools
+recognize the vendor directory as a location for these
+files. Glide has embraced this. Please remove the _vendor
+directory or move the _vendor/src/ directory to vendor/.` + "\n")
+		os.Exit(1)
+	}
+}
+
+// EnsureVendorDir ensures that a vendor/ directory is present in the cwd.
+func EnsureVendorDir() {
+	fi, err := os.Stat(gpath.VendorDir)
+	if err != nil {
+		msg.Debug("Creating %s", gpath.VendorDir)
+		if err := os.MkdirAll(gpath.VendorDir, os.ModeDir|0755); err != nil {
+			msg.Die("Could not create %s: %s", gpath.VendorDir, err)
+		}
+	} else if !fi.IsDir() {
+		msg.Die("Vendor is not a directory")
+	}
+}
+
+// EnsureGopath fails if GOPATH is not set, or if $GOPATH/src is missing.
+//
+// Otherwise it returns the value of GOPATH.
+func EnsureGopath() string {
+	gp := os.Getenv("GOPATH")
+	if gp == "" {
+		msg.Die("$GOPATH is not set.")
+	}
+	_, err := os.Stat(path.Join(gp, "src"))
+	if err != nil {
+		msg.Error("Could not find %s/src.\n", gp)
+		msg.Info("As of Glide 0.5/Go 1.5, this is required.\n")
+		msg.Die("Wihtout src, cannot continue. %s", err)
+	}
+	return gp
+}
diff --git a/action/get.go b/action/get.go
new file mode 100644
index 0000000..e7322ed
--- /dev/null
+++ b/action/get.go
@@ -0,0 +1,175 @@
+package action
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/glide/repo"
+	"github.com/Masterminds/glide/util"
+)
+
+// Get fetches one or more dependencies and installs.
+//
+// This includes resolving dependency resolution and re-generating the lock file.
+func Get(names []string, installer *repo.Installer, insecure, skipRecursive bool) {
+	base := gpath.Basepath()
+	EnsureGopath()
+	EnsureVendorDir()
+	conf := EnsureConfig()
+	glidefile, err := gpath.Glide()
+	if err != nil {
+		msg.Die("Could not find Glide file: %s", err)
+	}
+
+	// Add the packages to the config.
+	if err := addPkgsToConfig(conf, names, insecure); err != nil {
+		msg.Die("Failed to get new packages: %s", err)
+	}
+
+	// Fetch the new packages. Can't resolve versions via installer.Update if
+	// get is called while the vendor/ directory is empty so we checkout
+	// everything.
+	installer.Checkout(conf, false)
+
+	// Prior to resolving dependencies we need to start working with a clone
+	// of the conf because we'll be making real changes to it.
+	confcopy := conf.Clone()
+
+	if !skipRecursive {
+		// Get all repos and update them.
+		// TODO: Can we streamline this in any way? The reason that we update all
+		// of the dependencies is that we need to re-negotiate versions. For example,
+		// if an existing dependency has the constraint >1.0 and this new package
+		// adds the constraint <2.0, then this may re-resolve the existing dependency
+		// to be betwee 1.0 and 2.0. But changing that dependency may then result
+		// in that dependency's dependencies changing... so we sorta do the whole
+		// thing to be safe.
+		err = installer.Update(confcopy)
+		if err != nil {
+			msg.Die("Could not update packages: %s", err)
+		}
+	}
+
+	// Set Reference
+	if err := repo.SetReference(confcopy); err != nil {
+		msg.Error("Failed to set references: %s", err)
+	}
+
+	// VendoredCleanup
+	if installer.UpdateVendored {
+		repo.VendoredCleanup(confcopy)
+	}
+
+	// Write YAML
+	if err := conf.WriteFile(glidefile); err != nil {
+		msg.Die("Failed to write glide YAML file: %s", err)
+	}
+	if !skipRecursive {
+		// Write lock
+		writeLock(conf, confcopy, base)
+	} else {
+		msg.Warn("Skipping lockfile generation because full dependency tree is not being calculated")
+	}
+}
+
+func writeLock(conf, confcopy *cfg.Config, base string) {
+	hash, err := conf.Hash()
+	if err != nil {
+		msg.Die("Failed to generate config hash. Unable to generate lock file.")
+	}
+	lock := cfg.NewLockfile(confcopy.Imports, hash)
+	if err := lock.WriteFile(filepath.Join(base, gpath.LockFile)); err != nil {
+		msg.Die("Failed to write glide lock file: %s", err)
+	}
+}
+
+// addPkgsToConfig adds the given packages to the config file.
+//
+// Along the way it:
+// - ensures that this package is not in the ignore list
+// - checks to see if this is already in the dependency list.
+// - splits version of of package name and adds the version attribute
+// - seperates repo from packages
+// - sets up insecure repo URLs where necessary
+// - generates a list of subpackages
+func addPkgsToConfig(conf *cfg.Config, names []string, insecure bool) error {
+
+	msg.Info("Preparing to install %d package.", len(names))
+
+	for _, name := range names {
+		var version string
+		parts := strings.Split(name, "#")
+		if len(parts) > 1 {
+			name = parts[0]
+			version = parts[1]
+		}
+
+		root := util.GetRootFromPackage(name)
+		if len(root) == 0 {
+			return fmt.Errorf("Package name is required for %q.", name)
+		}
+
+		if conf.HasDependency(root) {
+
+			// Check if the subpackage is present.
+			subpkg := strings.TrimPrefix(name, root)
+			subpkg = strings.TrimPrefix(subpkg, "/")
+			if subpkg != "" {
+				found := false
+				dep := conf.Imports.Get(root)
+				for _, s := range dep.Subpackages {
+					if s == subpkg {
+						found = true
+						break
+					}
+				}
+				if found {
+					msg.Warn("Package %q is already in glide.yaml. Skipping", name)
+				} else {
+					dep.Subpackages = append(dep.Subpackages, subpkg)
+					msg.Info("Adding sub-package %s to existing import %s", subpkg, root)
+				}
+			} else {
+				msg.Warn("Package %q is already in glide.yaml. Skipping", root)
+			}
+			continue
+		}
+
+		if conf.HasIgnore(root) {
+			msg.Warn("Package %q is set to be ignored in glide.yaml. Skipping", root)
+			continue
+		}
+
+		dep := &cfg.Dependency{
+			Name: root,
+		}
+
+		if version != "" {
+			dep.Reference = version
+		}
+
+		// When retriving from an insecure location set the repo to the
+		// insecure location.
+		if insecure {
+			dep.Repository = "http://" + root
+		}
+
+		subpkg := strings.TrimPrefix(name, root)
+		if len(subpkg) > 0 && subpkg != "/" {
+			dep.Subpackages = []string{strings.TrimPrefix(subpkg, "/")}
+		}
+
+		if dep.Reference != "" {
+			msg.Info("Importing %s with the version %s", dep.Name, dep.Reference)
+		} else {
+			msg.Info("Importing %s", dep.Name)
+		}
+
+		conf.Imports = append(conf.Imports, dep)
+	}
+	return nil
+}
diff --git a/action/get_test.go b/action/get_test.go
new file mode 100644
index 0000000..94d18c7
--- /dev/null
+++ b/action/get_test.go
@@ -0,0 +1,46 @@
+package action
+
+import (
+	"io/ioutil"
+	"testing"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+)
+
+func TestAddPkgsToConfig(t *testing.T) {
+	// Route output to discard so it's not displayed with the test output.
+	o := msg.Default.Stderr
+	msg.Default.Stderr = ioutil.Discard
+
+	conf := new(cfg.Config)
+	dep := new(cfg.Dependency)
+	dep.Name = "github.com/Masterminds/cookoo"
+	dep.Subpackages = append(dep.Subpackages, "convert")
+	conf.Imports = append(conf.Imports, dep)
+
+	names := []string{
+		"github.com/Masterminds/cookoo/fmt",
+		"github.com/Masterminds/semver",
+	}
+
+	addPkgsToConfig(conf, names, false)
+
+	if !conf.HasDependency("github.com/Masterminds/semver") {
+		t.Error("addPkgsToConfig failed to add github.com/Masterminds/semver")
+	}
+
+	d := conf.Imports.Get("github.com/Masterminds/cookoo")
+	found := false
+	for _, s := range d.Subpackages {
+		if s == "fmt" {
+			found = true
+		}
+	}
+	if !found {
+		t.Error("addPkgsToConfig failed to add subpackage to existing import")
+	}
+
+	// Restore messaging to original location
+	msg.Default.Stderr = o
+}
diff --git a/action/import_gb.go b/action/import_gb.go
new file mode 100644
index 0000000..6f836ff
--- /dev/null
+++ b/action/import_gb.go
@@ -0,0 +1,50 @@
+package action
+
+import (
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/gb"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+)
+
+// ImportGB imports GB dependencies into the present glide config.
+func ImportGB(dest string) {
+	base := "."
+	config := EnsureConfig()
+	if !gb.Has(base) {
+		msg.Die("There is no GB manifest to import.")
+	}
+	deps, err := gb.Parse(base)
+	if err != nil {
+		msg.Die("Failed to extract GB manifest: %s", err)
+	}
+	appendImports(deps, config)
+	writeConfigToFileOrStdout(config, dest)
+}
+
+func appendImports(deps []*cfg.Dependency, config *cfg.Config) {
+	if len(deps) == 0 {
+		msg.Info("No dependencies added.")
+		return
+	}
+
+	//Append deps to existing dependencies.
+	if err := config.AddImport(deps...); err != nil {
+		msg.Die("Failed to add imports: %s", err)
+	}
+}
+
+// writeConfigToFileOrStdout is a convenience function for import utils.
+func writeConfigToFileOrStdout(config *cfg.Config, dest string) {
+	if dest != "" {
+		if err := config.WriteFile(dest); err != nil {
+			msg.Die("Failed to write %s: %s", gpath.GlideFile, err)
+		}
+	} else {
+		o, err := config.Marshal()
+		if err != nil {
+			msg.Die("Error encoding config: %s", err)
+		}
+		msg.Default.Stdout.Write(o)
+	}
+}
diff --git a/action/import_godep.go b/action/import_godep.go
new file mode 100644
index 0000000..0c626d3
--- /dev/null
+++ b/action/import_godep.go
@@ -0,0 +1,21 @@
+package action
+
+import (
+	"github.com/Masterminds/glide/godep"
+	"github.com/Masterminds/glide/msg"
+)
+
+// ImportGodep imports a GPM file.
+func ImportGodep(dest string) {
+	base := "."
+	config := EnsureConfig()
+	if !godep.Has(base) {
+		msg.Die("No Godep data found.")
+	}
+	deps, err := godep.Parse(base)
+	if err != nil {
+		msg.Die("Failed to extract Godeps file: %s", err)
+	}
+	appendImports(deps, config)
+	writeConfigToFileOrStdout(config, dest)
+}
diff --git a/action/import_gpm.go b/action/import_gpm.go
new file mode 100644
index 0000000..b91bba5
--- /dev/null
+++ b/action/import_gpm.go
@@ -0,0 +1,21 @@
+package action
+
+import (
+	"github.com/Masterminds/glide/gpm"
+	"github.com/Masterminds/glide/msg"
+)
+
+// ImportGPM imports a GPM file.
+func ImportGPM(dest string) {
+	base := "."
+	config := EnsureConfig()
+	if !gpm.Has(base) {
+		msg.Die("No GPM Godeps file found.")
+	}
+	deps, err := gpm.Parse(base)
+	if err != nil {
+		msg.Die("Failed to extract GPM Godeps file: %s", err)
+	}
+	appendImports(deps, config)
+	writeConfigToFileOrStdout(config, dest)
+}
diff --git a/action/init.go b/action/init.go
new file mode 100644
index 0000000..b0c29da
--- /dev/null
+++ b/action/init.go
@@ -0,0 +1,11 @@
+package action
+
+import (
+	gpath "github.com/Masterminds/glide/path"
+)
+
+// Init initializes the action subsystem for handling one or more subesequent actions.
+func Init(yaml, home string) {
+	gpath.GlideFile = yaml
+	gpath.HomeDir = home
+}
diff --git a/action/install.go b/action/install.go
new file mode 100644
index 0000000..84ab8c3
--- /dev/null
+++ b/action/install.go
@@ -0,0 +1,84 @@
+package action
+
+import (
+	"io/ioutil"
+	"path/filepath"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/dependency"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/glide/repo"
+)
+
+// Install installs a vendor directory based on an existing Glide configuration.
+func Install(installer *repo.Installer) {
+	base := "."
+	// Ensure GOPATH
+	EnsureGopath()
+	EnsureVendorDir()
+	conf := EnsureConfig()
+
+	// Lockfile exists
+	if !gpath.HasLock(base) {
+		msg.Info("Lock file (glide.lock) does not exist. Performing update.")
+		msg.Die("No update performed. FIXME.")
+		// Update(installer)
+	}
+	// Load lockfile
+	lock, err := LoadLockfile(base, conf)
+	if err != nil {
+		msg.Die("Could not load lockfile.")
+	}
+
+	// Delete unused packages
+	if installer.DeleteUnused {
+		// It's unclear whether this should operate off of the lock, or off
+		// of the glide.yaml file. I'd think that doing this based on the
+		// lock would be much more reliable.
+		dependency.DeleteUnused(conf)
+	}
+
+	// Install
+	newConf, err := installer.Install(lock, conf)
+	if err != nil {
+		msg.Die("Failed to install: %s", err)
+	}
+
+	msg.Info("Setting references.")
+
+	// Set reference
+	if err := repo.SetReference(newConf); err != nil {
+		msg.Error("Failed to set references: %s (Skip to cleanup)", err)
+	}
+
+	// VendoredCleanup. This should ONLY be run if UpdateVendored was specified.
+	if installer.UpdateVendored {
+		repo.VendoredCleanup(newConf)
+	}
+}
+
+// LoadLockfile loads the contents of a glide.lock file.
+//
+// TODO: This should go in another package.
+func LoadLockfile(base string, conf *cfg.Config) (*cfg.Lockfile, error) {
+	yml, err := ioutil.ReadFile(filepath.Join(base, gpath.LockFile))
+	if err != nil {
+		return nil, err
+	}
+	lock, err := cfg.LockfileFromYaml(yml)
+	if err != nil {
+		return nil, err
+	}
+
+	hash, err := conf.Hash()
+	if err != nil {
+		return nil, err
+	}
+
+	if hash != lock.Hash {
+		msg.Warn("Lock file may be out of date. Hash check of YAML failed. You may need to run 'update'")
+	}
+
+	return lock, nil
+}
diff --git a/action/list.go b/action/list.go
new file mode 100644
index 0000000..067e3ca
--- /dev/null
+++ b/action/list.go
@@ -0,0 +1,59 @@
+package action
+
+import (
+	"path/filepath"
+	"sort"
+
+	"github.com/Masterminds/glide/dependency"
+	"github.com/Masterminds/glide/msg"
+)
+
+// List lists all of the dependencies of the current project.
+//
+// Params:
+//  - dir (string): basedir
+//  - deep (bool): whether to do a deep scan or a shallow scan
+func List(basedir string, deep bool) {
+
+	basedir, err := filepath.Abs(basedir)
+	if err != nil {
+		msg.Die("Could not read directory: %s", err)
+	}
+
+	r, err := dependency.NewResolver(basedir)
+	if err != nil {
+		msg.Die("Could not create a resolver: %s", err)
+	}
+	h := &dependency.DefaultMissingPackageHandler{Missing: []string{}, Gopath: []string{}}
+	r.Handler = h
+
+	sortable, err := r.ResolveLocal(deep)
+	if err != nil {
+		msg.Die("Error listing dependencies: %s", err)
+	}
+
+	sort.Strings(sortable)
+
+	msg.Puts("INSTALLED packages:")
+	for _, k := range sortable {
+		v, err := filepath.Rel(basedir, k)
+		if err != nil {
+			msg.Warn("Failed to Rel path: %s", err)
+			v = k
+		}
+		msg.Puts("\t%s", v)
+	}
+
+	if len(h.Missing) > 0 {
+		msg.Puts("\nMISSING packages:")
+		for _, pkg := range h.Missing {
+			msg.Puts("\t%s", pkg)
+		}
+	}
+	if len(h.Gopath) > 0 {
+		msg.Puts("\nGOPATH packages:")
+		for _, pkg := range h.Gopath {
+			msg.Puts("\t%s", pkg)
+		}
+	}
+}
diff --git a/action/list_test.go b/action/list_test.go
new file mode 100644
index 0000000..6792210
--- /dev/null
+++ b/action/list_test.go
@@ -0,0 +1,21 @@
+package action
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/Masterminds/glide/msg"
+)
+
+func TestList(t *testing.T) {
+	var buf bytes.Buffer
+	old := msg.Default.Stdout
+	msg.Default.PanicOnDie = true
+	msg.Default.Stdout = &buf
+	List("../", false)
+	if buf.Len() < 5 {
+		t.Error("Expected some data to be found.")
+	}
+	// TODO: We should capture and test output.
+	msg.Default.Stdout = old
+}
diff --git a/action/name.go b/action/name.go
new file mode 100644
index 0000000..77972b3
--- /dev/null
+++ b/action/name.go
@@ -0,0 +1,11 @@
+package action
+
+import (
+	"github.com/Masterminds/glide/msg"
+)
+
+// Name prints the name of the package, according to the glide.yaml file.
+func Name() {
+	conf := EnsureConfig()
+	msg.Puts(conf.Name)
+}
diff --git a/action/name_test.go b/action/name_test.go
new file mode 100644
index 0000000..244d03b
--- /dev/null
+++ b/action/name_test.go
@@ -0,0 +1,26 @@
+package action
+
+import (
+	"bytes"
+	"os"
+	"testing"
+
+	"github.com/Masterminds/glide/msg"
+)
+
+func TestName(t *testing.T) {
+	var buf bytes.Buffer
+	msg.Default.PanicOnDie = true
+	ostdout := msg.Default.Stdout
+	msg.Default.Stdout = &buf
+	wd, _ := os.Getwd()
+	if err := os.Chdir("../testdata/name"); err != nil {
+		t.Errorf("Failed to change directory: %s", err)
+	}
+	Name()
+	if buf.String() != "technosophos.com/x/foo\n" {
+		t.Errorf("Unexpectedly got name %q", buf.String())
+	}
+	msg.Default.Stdout = ostdout
+	os.Chdir(wd)
+}
diff --git a/action/no_vendor.go b/action/no_vendor.go
new file mode 100644
index 0000000..95a0126
--- /dev/null
+++ b/action/no_vendor.go
@@ -0,0 +1,143 @@
+package action
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/Masterminds/glide/msg"
+)
+
+// NoVendor generates a list of source code directories, excepting `vendor/`.
+//
+// If "onlyGo" is true, only folders that have Go code in them will be returned.
+//
+// If suffix is true, this will append `/...` to every directory.
+func NoVendor(path string, onlyGo, suffix bool) {
+	// This is responsible for printing the results of noVend.
+	paths, err := noVend(path, onlyGo, suffix)
+	if err != nil {
+		msg.Error("Failed to walk file tree: %s", err)
+		msg.Warn("FIXME: NoVendor should exit with non-zero exit code.")
+		return
+	}
+
+	for _, p := range paths {
+		msg.Puts(p)
+	}
+}
+
+// noVend takes a directory and returns a list of Go-like files or directories,
+// provided the directory is not a vendor directory.
+//
+// If onlyGo is true, this will filter out all directories that do not contain
+// ".go" files.
+//
+// TODO: Should we move this to its own package?
+func noVend(path string, onlyGo, suffix bool) ([]string, error) {
+
+	info, err := os.Stat(path)
+	if err != nil {
+		return []string{}, err
+	}
+
+	if !info.IsDir() {
+		return []string{path}, nil
+	}
+
+	res := []string{}
+	f, err := os.Open(path)
+	if err != nil {
+		return res, err
+	}
+
+	fis, err := f.Readdir(0)
+	if err != nil {
+		return res, err
+	}
+
+	cur := false
+
+	for _, fi := range fis {
+		if exclude(fi) {
+			continue
+		}
+
+		full := filepath.Join(path, fi.Name())
+		if fi.IsDir() && !isVend(fi) {
+			p := "./" + full + "/..."
+			res = append(res, p)
+		} else if !fi.IsDir() && isGoish(fi) {
+			//res = append(res, full)
+			cur = true
+		}
+	}
+
+	// Filter out directories that do not contain Go code
+	if onlyGo {
+		res = hasGoSource(res, suffix)
+	}
+
+	if cur {
+		res = append(res, ".")
+	}
+
+	return res, nil
+}
+
+// hasGoSource returns a list of directories that contain Go source.
+func hasGoSource(dirs []string, suffix bool) []string {
+	suf := "/"
+	if suffix {
+		suf = "/..."
+	}
+	buf := []string{}
+	for _, d := range dirs {
+		d := filepath.Dir(d)
+		found := false
+		walker := func(p string, fi os.FileInfo, err error) error {
+			// Dumb optimization
+			if found {
+				return nil
+			}
+
+			// If the file ends with .go, report a match.
+			if strings.ToLower(filepath.Ext(p)) == ".go" {
+				found = true
+			}
+
+			return nil
+		}
+		filepath.Walk(d, walker)
+
+		if found {
+			buf = append(buf, "./"+d+suf)
+		}
+	}
+	return buf
+}
+
+// isVend returns true of this directory is a vendor directory.
+//
+// TODO: Should we return true for Godeps directory?
+func isVend(fi os.FileInfo) bool {
+	return fi.Name() == "vendor"
+}
+
+// exclude returns true if the directory should be excluded by Go toolchain tools.
+//
+// Examples: directories prefixed with '.' or '_'.
+func exclude(fi os.FileInfo) bool {
+	if strings.HasPrefix(fi.Name(), "_") {
+		return true
+	}
+	if strings.HasPrefix(fi.Name(), ".") {
+		return true
+	}
+	return false
+}
+
+// isGoish returns true if the file appears to be Go source.
+func isGoish(fi os.FileInfo) bool {
+	return filepath.Ext(fi.Name()) == ".go"
+}
diff --git a/action/no_vendor_test.go b/action/no_vendor_test.go
new file mode 100644
index 0000000..be6fed3
--- /dev/null
+++ b/action/no_vendor_test.go
@@ -0,0 +1,12 @@
+package action
+
+import (
+	"testing"
+
+	"github.com/Masterminds/glide/msg"
+)
+
+func TestNoVendor(t *testing.T) {
+	msg.Default.PanicOnDie = true
+	NoVendor("../testdata/nv", false, false)
+}
diff --git a/action/plugin.go b/action/plugin.go
new file mode 100644
index 0000000..66da2ad
--- /dev/null
+++ b/action/plugin.go
@@ -0,0 +1,59 @@
+package action
+
+import (
+	"os"
+	"os/exec"
+
+	"github.com/Masterminds/glide/msg"
+)
+
+// Plugin attempts to find and execute a plugin based on a command.
+//
+// Exit code 99 means the plugin was never executed. Code 1 means the program
+// exited badly.
+func Plugin(command string, args []string) {
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		msg.ExitCode(99)
+		msg.Die("Could not get working directory: %s", err)
+	}
+
+	cmd := "glide-" + command
+	var fullcmd string
+	if fullcmd, err = exec.LookPath(cmd); err != nil {
+		fullcmd = cwd + "/" + cmd
+		if _, err := os.Stat(fullcmd); err != nil {
+			msg.ExitCode(99)
+			msg.Die("Command %s does not exist.", cmd)
+		}
+	}
+
+	// Turning os.Args first argument from `glide` to `glide-command`
+	args[0] = cmd
+	// Removing the first argument (command)
+	removed := false
+	for i, v := range args {
+		if removed == false && v == command {
+			args = append(args[:i], args[i+1:]...)
+			removed = true
+		}
+	}
+	pa := os.ProcAttr{
+		Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
+		Dir:   cwd,
+	}
+
+	msg.Debug("Delegating to plugin %s (%v)\n", fullcmd, args)
+
+	proc, err := os.StartProcess(fullcmd, args, &pa)
+	if err != nil {
+		msg.Error("Failed to execute %s: %s", cmd, err)
+		os.Exit(98)
+	}
+
+	if _, err := proc.Wait(); err != nil {
+		msg.Error(err.Error())
+		os.Exit(1)
+	}
+}
diff --git a/action/plugin_test.go b/action/plugin_test.go
new file mode 100644
index 0000000..95a7b15
--- /dev/null
+++ b/action/plugin_test.go
@@ -0,0 +1,19 @@
+package action
+
+import (
+	"os"
+	"testing"
+
+	"github.com/Masterminds/glide/msg"
+)
+
+func TestPlugin(t *testing.T) {
+	wd, _ := os.Getwd()
+	os.Chdir("../testdata/plugin")
+	msg.Default.PanicOnDie = true
+	cmd := "hello"
+	args := []string{"a", "b"}
+	// FIXME: Trapping the panic is the nice thing to do.
+	Plugin(cmd, args)
+	os.Chdir(wd)
+}
diff --git a/action/rebuild.go b/action/rebuild.go
new file mode 100644
index 0000000..d53b774
--- /dev/null
+++ b/action/rebuild.go
@@ -0,0 +1,98 @@
+package action
+
+import (
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+)
+
+// Rebuild rebuilds '.a' files for a project.
+//
+// Prior to Go 1.4, this could substantially reduce time on incremental compiles.
+// It remains to be seen whether this is tremendously beneficial to modern Go
+// programs.
+func Rebuild() {
+	conf := EnsureConfig()
+	vpath, err := gpath.Vendor()
+	if err != nil {
+		msg.Die("Could not get vendor path: %s", err)
+	}
+
+	msg.Info("Building dependencies.\n")
+
+	if len(conf.Imports) == 0 {
+		msg.Info("No dependencies found. Nothing built.\n")
+		return
+	}
+
+	for _, dep := range conf.Imports {
+		if err := buildDep(dep, vpath); err != nil {
+			msg.Warn("Failed to build %s: %s\n", dep.Name, err)
+		}
+	}
+}
+
+func buildDep(dep *cfg.Dependency, vpath string) error {
+	if len(dep.Subpackages) == 0 {
+		buildPath(dep.Name)
+	}
+
+	for _, pkg := range dep.Subpackages {
+		if pkg == "**" || pkg == "..." {
+			//Info("Building all packages in %s\n", dep.Name)
+			buildPath(path.Join(dep.Name, "..."))
+		} else {
+			paths, err := resolvePackages(vpath, dep.Name, pkg)
+			if err != nil {
+				msg.Warn("Error resolving packages: %s", err)
+			}
+			buildPaths(paths)
+		}
+	}
+
+	return nil
+}
+
+func resolvePackages(vpath, pkg, subpkg string) ([]string, error) {
+	sdir, _ := os.Getwd()
+	if err := os.Chdir(filepath.Join(vpath, pkg, subpkg)); err != nil {
+		return []string{}, err
+	}
+	defer os.Chdir(sdir)
+	p, err := filepath.Glob(path.Join(vpath, pkg, subpkg))
+	if err != nil {
+		return []string{}, err
+	}
+	for k, v := range p {
+		nv := strings.TrimPrefix(v, vpath)
+		p[k] = strings.TrimPrefix(nv, string(filepath.Separator))
+	}
+	return p, nil
+}
+
+func buildPaths(paths []string) error {
+	for _, path := range paths {
+		if err := buildPath(path); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func buildPath(path string) error {
+	msg.Info("Running go build %s\n", path)
+	// . in a filepath.Join is removed so it needs to be prepended separately.
+	p := "." + string(filepath.Separator) + filepath.Join("vendor", path)
+	out, err := exec.Command("go", "install", p).CombinedOutput()
+	if err != nil {
+		msg.Warn("Failed to run 'go install' for %s: %s", path, string(out))
+	}
+	return err
+}
diff --git a/action/rebuild_test.go b/action/rebuild_test.go
new file mode 100644
index 0000000..dfcdf0e
--- /dev/null
+++ b/action/rebuild_test.go
@@ -0,0 +1,18 @@
+package action
+
+import (
+	"os"
+	"testing"
+
+	"github.com/Masterminds/glide/msg"
+)
+
+func TestRebuild(t *testing.T) {
+	msg.Default.PanicOnDie = true
+	wd, _ := os.Getwd()
+	if err := os.Chdir("../testdata/rebuild"); err != nil {
+		t.Errorf("Could not change dir: %s (%s)", err, wd)
+	}
+	Rebuild()
+	os.Chdir(wd)
+}
diff --git a/action/remove.go b/action/remove.go
new file mode 100644
index 0000000..e0978b0
--- /dev/null
+++ b/action/remove.go
@@ -0,0 +1,66 @@
+package action
+
+import (
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/glide/repo"
+)
+
+func Remove(packages []string, inst *repo.Installer) {
+	base := gpath.Basepath()
+	EnsureGopath()
+	EnsureVendorDir()
+	conf := EnsureConfig()
+	glidefile, err := gpath.Glide()
+	if err != nil {
+		msg.Die("Could not find Glide file: %s", err)
+	}
+
+	msg.Info("Preparing to remove %d packages.", len(packages))
+	conf.Imports = rmDeps(packages, conf.Imports)
+	conf.DevImports = rmDeps(packages, conf.DevImports)
+
+	// Copy used to generate locks.
+	confcopy := conf.Clone()
+
+	confcopy.Imports = inst.List(confcopy)
+
+	if err := repo.SetReference(confcopy); err != nil {
+		msg.Error("Failed to set references: %s", err)
+	}
+
+	// TODO: Right now, there is no flag to enable this, so this will never be
+	// run. I am not sure whether we should allow this in a rm op or not.
+	if inst.UpdateVendored {
+		repo.VendoredCleanup(confcopy)
+	}
+
+	// Write glide.yaml
+	if err := conf.WriteFile(glidefile); err != nil {
+		msg.Die("Failed to write glide YAML file: %s", err)
+	}
+
+	// Write glide lock
+	writeLock(conf, confcopy, base)
+}
+
+// rmDeps returns a list of dependencies that do not contain the given pkgs.
+//
+// It generates neither an error nor a warning for a pkg that does not exist
+// in the list of deps.
+func rmDeps(pkgs []string, deps []*cfg.Dependency) []*cfg.Dependency {
+	res := []*cfg.Dependency{}
+	for _, d := range deps {
+		rem := false
+		for _, p := range pkgs {
+			if p == d.Name {
+				rem = true
+			}
+		}
+		if !rem {
+			res = append(res, d)
+		}
+	}
+	return res
+}
diff --git a/action/tree.go b/action/tree.go
new file mode 100644
index 0000000..a43a6ba
--- /dev/null
+++ b/action/tree.go
@@ -0,0 +1,32 @@
+package action
+
+import (
+	"container/list"
+	"os"
+
+	"github.com/Masterminds/glide/msg"
+	"github.com/Masterminds/glide/tree"
+	"github.com/Masterminds/glide/util"
+)
+
+// Tree prints a tree representing dependencies.
+func Tree(basedir string, showcore bool) {
+	buildContext, err := util.GetBuildContext()
+	if err != nil {
+		msg.Die("Failed to get a build context: %s", err)
+	}
+	myName := buildContext.PackageName(basedir)
+
+	if basedir == "." {
+		var err error
+		basedir, err = os.Getwd()
+		if err != nil {
+			msg.Die("Could not get working directory")
+		}
+	}
+
+	msg.Puts(myName)
+	l := list.New()
+	l.PushBack(myName)
+	tree.Display(buildContext, basedir, myName, 1, showcore, l)
+}
diff --git a/action/update.go b/action/update.go
new file mode 100644
index 0000000..c989e37
--- /dev/null
+++ b/action/update.go
@@ -0,0 +1,92 @@
+package action
+
+import (
+	"path/filepath"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/dependency"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/glide/repo"
+)
+
+// Update updates repos and the lock file from the main glide yaml.
+func Update(installer *repo.Installer, skipRecursive bool) {
+	base := "."
+	EnsureGopath()
+	EnsureVendorDir()
+	conf := EnsureConfig()
+
+	installer.RootPackage = conf.Name
+
+	// Delete unused packages
+	if installer.DeleteUnused {
+		dependency.DeleteUnused(conf)
+	}
+
+	// Try to check out the initial dependencies.
+	if err := installer.Checkout(conf, false); err != nil {
+		msg.Die("Failed to do initial checkout of config: %s", err)
+	}
+
+	// Set the versions for the initial dependencies so that resolved dependencies
+	// are rooted in the correct version of the base.
+	if err := repo.SetReference(conf); err != nil {
+		msg.Die("Failed to set initial config references: %s", err)
+	}
+
+	// Prior to resolving dependencies we need to start working with a clone
+	// of the conf because we'll be making real changes to it.
+	confcopy := conf.Clone()
+
+	if !skipRecursive {
+		// Get all repos and update them.
+		err := installer.Update(confcopy)
+		if err != nil {
+			msg.Die("Could not update packages: %s", err)
+		}
+
+		// TODO: There is no support here for importing Godeps, GPM, and GB files.
+		// I think that all we really need to do now is hunt for these files, and then
+		// roll their version numbers into the config file.
+
+		// Set references. There may be no remaining references to set since the
+		// installer set them as it went to make sure it parsed the right imports
+		// from the right version of the package.
+		msg.Info("Setting references for remaining imports")
+		if err := repo.SetReference(confcopy); err != nil {
+			msg.Error("Failed to set references: %s (Skip to cleanup)", err)
+		}
+	}
+	// Vendored cleanup
+	// VendoredCleanup. This should ONLY be run if UpdateVendored was specified.
+	if installer.UpdateVendored {
+		repo.VendoredCleanup(confcopy)
+	}
+
+	// Write glide.yaml (Why? Godeps/GPM/GB?)
+	// I think we don't need to write a new Glide file because update should not
+	// change anything important. It will just generate information about
+	// transative dependencies, all of which belongs exclusively in the lock
+	// file, not the glide.yaml file.
+	// TODO(mattfarina): Detect when a new dependency has been added or removed
+	// from the project. A removed dependency should warn and an added dependency
+	// should be added to the glide.yaml file. See issue #193.
+
+	if !skipRecursive {
+		// Write lock
+		hash, err := conf.Hash()
+		if err != nil {
+			msg.Die("Failed to generate config hash. Unable to generate lock file.")
+		}
+		lock := cfg.NewLockfile(confcopy.Imports, hash)
+		if err := lock.WriteFile(filepath.Join(base, gpath.LockFile)); err != nil {
+			msg.Error("Could not write lock file to %s: %s", base, err)
+			return
+		}
+
+		msg.Info("Project relies on %d dependencies.", len(confcopy.Imports))
+	} else {
+		msg.Warn("Skipping lockfile generation because full dependency tree is not being calculated")
+	}
+}
diff --git a/cfg/config.go b/cfg/config.go
index 8e3e107..cca4072 100644
--- a/cfg/config.go
+++ b/cfg/config.go
@@ -3,6 +3,7 @@
 import (
 	"crypto/sha256"
 	"fmt"
+	"io/ioutil"
 	"reflect"
 	"strings"
 
@@ -19,7 +20,7 @@
 	DevImports Dependencies `yaml:"devimport,omitempty"`
 }
 
-// A transitive representation of a dependency for importing and exploting to yaml.
+// A transitive representation of a dependency for importing and exporting to yaml.
 type cf struct {
 	Name       string       `yaml:"package"`
 	Ignore     []string     `yaml:"ignore,omitempty"`
@@ -100,7 +101,10 @@
 // HasIgnore returns true if the given name is listed on the ignore list.
 func (c *Config) HasIgnore(name string) bool {
 	for _, v := range c.Ignore {
-		if v == name {
+
+		// Check for both a name and to make sure sub-packages are ignored as
+		// well.
+		if v == name || strings.HasPrefix(name, v+"/") {
 			return true
 		}
 	}
@@ -118,6 +122,18 @@
 	return n
 }
 
+// WriteFile writes a Glide YAML file.
+//
+// This is a convenience function that marshals the YAML and then writes it to
+// the given file. If the file exists, it will be clobbered.
+func (c *Config) WriteFile(glidepath string) error {
+	o, err := c.Marshal()
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(glidepath, o, 0666)
+}
+
 // DeDupe consolidates duplicate dependencies on a Config instance
 func (c *Config) DeDupe() error {
 
@@ -179,6 +195,18 @@
 	return nil
 }
 
+// AddImport appends dependencies to the import list, deduplicating as we go.
+func (c *Config) AddImport(deps ...*Dependency) error {
+	t := c.Imports
+	t = append(t, deps...)
+	t, err := t.DeDupe()
+	if err != nil {
+		return err
+	}
+	c.Imports = t
+	return nil
+}
+
 // Hash generates a sha256 hash for a given Config
 func (c *Config) Hash() (string, error) {
 	yml, err := c.Marshal()
@@ -206,7 +234,7 @@
 
 // Clone performs a deep clone of Dependencies
 func (d Dependencies) Clone() Dependencies {
-	n := make(Dependencies, 0, 1)
+	n := make(Dependencies, 0, len(d))
 	for _, v := range d {
 		n = append(n, v.Clone())
 	}
@@ -368,6 +396,18 @@
 	}
 }
 
+// HasSubpackage returns if the subpackage is present on the dependency
+func (d *Dependency) HasSubpackage(sub string) bool {
+
+	for _, v := range d.Subpackages {
+		if sub == v {
+			return true
+		}
+	}
+
+	return false
+}
+
 func stringArrayDeDupe(s []string, items ...string) []string {
 	for _, item := range items {
 		exists := false
diff --git a/cfg/lock.go b/cfg/lock.go
index 921fe33..bbb959f 100644
--- a/cfg/lock.go
+++ b/cfg/lock.go
@@ -1,6 +1,7 @@
 package cfg
 
 import (
+	"io/ioutil"
 	"sort"
 	"strings"
 	"time"
@@ -32,6 +33,18 @@
 	return yml, nil
 }
 
+// WriteFile writes a Glide lock file.
+//
+// This is a convenience function that marshals the YAML and then writes it to
+// the given file. If the file exists, it will be clobbered.
+func (lf *Lockfile) WriteFile(lockpath string) error {
+	o, err := lf.Marshal()
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(lockpath, o, 0666)
+}
+
 type Locks []*Lock
 
 // Len returns the length of the Locks. This is needed for sorting with
diff --git a/cmd/drop_shell.go b/cmd/drop_shell.go
deleted file mode 100644
index ef65231..0000000
--- a/cmd/drop_shell.go
+++ /dev/null
@@ -1,69 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-
-	"github.com/Masterminds/cookoo"
-)
-
-// DropToShell executes a glide plugin. A command that's implemented by
-// another application is executed in a similar manner to the way git commands
-// work. For example, 'glide foo' would try to execute the application glide-foo.
-// Params:
-//   - command: the name of the command to attempt executing.
-func DropToShell(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	args := c.Get("os.Args", nil).([]string)
-	command := p.Get("command", "").(string)
-
-	if len(args) == 0 {
-		return nil, fmt.Errorf("Could not get os.Args.")
-	}
-
-	cwd, err := os.Getwd()
-	if err != nil {
-		return nil, err
-	}
-
-	projpath := cwd
-	if tmp := os.Getenv("GLIDE_PROJECT"); len(tmp) != 0 {
-		projpath = tmp
-	}
-
-	cmd := "glide-" + command
-	var fullcmd string
-	if fullcmd, err = exec.LookPath(cmd); err != nil {
-		fullcmd = projpath + "/" + cmd
-		if _, err := os.Stat(fullcmd); err != nil {
-			return nil, fmt.Errorf("Command %s does not exist.", cmd)
-		}
-	}
-
-	// Turning os.Args first argument from `glide` to `glide-command`
-	args[0] = cmd
-	// Removing the first argument (command)
-	removed := false
-	for i, v := range args {
-		if removed == false && v == command {
-			args = append(args[:i], args[i+1:]...)
-			removed = true
-		}
-	}
-	pa := os.ProcAttr{
-		Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
-		Dir:   cwd,
-	}
-
-	fmt.Printf("Delegating to plugin %s (%v)\n", fullcmd, args)
-
-	proc, err := os.StartProcess(fullcmd, args, &pa)
-	if err != nil {
-		return nil, err
-	}
-
-	if _, err := proc.Wait(); err != nil {
-		return nil, err
-	}
-	return nil, nil
-}
diff --git a/cmd/flatten.go b/cmd/flatten.go
deleted file mode 100644
index 9ae94f7..0000000
--- a/cmd/flatten.go
+++ /dev/null
@@ -1,479 +0,0 @@
-package cmd
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-	"github.com/Masterminds/glide/util"
-	"github.com/Masterminds/semver"
-)
-
-// Flatten recurses through all dependent packages and flattens to a top level.
-//
-// Flattening involves determining a tree's dependencies and flattening them
-// into a single large list.
-//
-// Params:
-//	- packages ([]string): The packages to read. If this is empty, it reads all
-//		packages.
-//	- force (bool): force vcs updates.
-//	- conf (*cfg.Config): The configuration.
-//
-// Returns:
-//
-func Flatten(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	conf := p.Get("conf", &cfg.Config{}).(*cfg.Config)
-	skip := p.Get("skip", false).(bool)
-	home := p.Get("home", "").(string)
-	cache := p.Get("cache", false).(bool)
-	cacheGopath := p.Get("cacheGopath", false).(bool)
-	useGopath := p.Get("useGopath", false).(bool)
-
-	if skip {
-		Warn("Skipping lockfile generation because full dependency tree is not being calculated")
-		return conf, nil
-	}
-	packages := p.Get("packages", []string{}).([]string)
-
-	// Operate on a clone of the conf so any changes don't impact later operations.
-	// This is a deep clone so dependencies are also cloned.
-	confcopy := conf.Clone()
-
-	// Generate a hash of the conf for later use in lockfile generation.
-	hash, err := conf.Hash()
-	if err != nil {
-		return conf, err
-	}
-
-	// When packages are passed around with a #version on the end it needs
-	// to be stripped.
-	for k, v := range packages {
-		parts := strings.Split(v, "#")
-		packages[k] = parts[0]
-	}
-
-	force := p.Get("force", true).(bool)
-	vend, _ := VendorPath(c)
-
-	// If no packages are supplied, we do them all.
-	if len(packages) == 0 {
-		packages = make([]string, len(confcopy.Imports))
-		for i, v := range confcopy.Imports {
-			packages[i] = v.Name
-		}
-	}
-
-	// Build an initial dependency map.
-	deps := make(map[string]*cfg.Dependency, len(confcopy.Imports))
-	for _, imp := range confcopy.Imports {
-		deps[imp.Name] = imp
-	}
-
-	f := &flattening{confcopy, vend, vend, deps, packages}
-
-	// The assumption here is that once something has been scanned once in a
-	// run, there is no need to scan it again.
-	scanned := map[string]bool{}
-	err = recFlatten(f, force, home, cache, cacheGopath, useGopath, scanned)
-	if err != nil {
-		return confcopy, err
-	}
-	err = confcopy.DeDupe()
-	if err != nil {
-		return confcopy, err
-	}
-	flattenSetRefs(f)
-	Info("Project relies on %d dependencies.", len(deps))
-
-	c.Put("Lockfile", cfg.LockfileFromMap(deps, hash))
-
-	exportFlattenedDeps(confcopy, deps)
-
-	return confcopy, err
-}
-
-func exportFlattenedDeps(conf *cfg.Config, in map[string]*cfg.Dependency) {
-	out := make([]*cfg.Dependency, len(in))
-	i := 0
-	for _, v := range in {
-		out[i] = v
-		i++
-	}
-	conf.Imports = out
-}
-
-type flattening struct {
-	conf *cfg.Config
-	// Top vendor path, e.g. project/vendor
-	top string
-	// Current path
-	curr string
-	// Built list of dependencies
-	deps map[string]*cfg.Dependency
-	// Dependencies that need to be scanned.
-	scan []string
-}
-
-// Hack: Cache record of updates so we don't have to keep doing git pulls.
-var updateCache = map[string]bool{}
-
-// refFlatten recursively flattens the vendor tree.
-func recFlatten(f *flattening, force bool, home string, cache, cacheGopath, useGopath bool, scanned map[string]bool) error {
-	Debug("---> Inspecting %s for changes (%d packages).\n", f.curr, len(f.scan))
-	for _, imp := range f.scan {
-		Debug("----> Scanning %s", imp)
-		base := filepath.Join(f.top, filepath.FromSlash(imp))
-		mod := []string{}
-		if m, ok := mergeGlide(base, imp, f); ok {
-			mod = m
-		} else if m, ok = mergeGodep(base, imp, f); ok {
-			mod = m
-		} else if m, ok = mergeGPM(base, imp, f); ok {
-			mod = m
-		} else if m, ok = mergeGb(base, imp, f); ok {
-			mod = m
-		} else if m, ok = mergeGuess(base, imp, f, scanned); ok {
-			mod = m
-		}
-
-		if len(mod) > 0 {
-			Debug("----> Updating all dependencies for %q (%d)", imp, len(mod))
-			flattenGlideUp(f, base, home, force, cache, cacheGopath, useGopath)
-			f2 := &flattening{
-				conf: f.conf,
-				top:  f.top,
-				curr: base,
-				deps: f.deps,
-				scan: mod}
-			recFlatten(f2, force, home, cache, cacheGopath, useGopath, scanned)
-		}
-	}
-
-	return nil
-}
-
-// flattenGlideUp does a glide update in the middle of a flatten operation.
-//
-// While this is expensive, it is also necessary to make sure we have the
-// correct version of all dependencies. We might be able to simplify by
-// marking packages dirty when they are added.
-func flattenGlideUp(f *flattening, base, home string, force, cache, cacheGopath, useGopath bool) error {
-	//vdir := path.Join(base, "vendor")
-	for _, imp := range f.deps {
-		// If the top package name in the glide.yaml file is present in the deps
-		// skip it because we already have it.
-		if imp.Name == f.conf.Name {
-			continue
-		}
-		wd := filepath.Join(f.top, filepath.FromSlash(imp.Name))
-
-		if updateCache[imp.Name] {
-			Debug("----> Already updated %s", imp.Name)
-			continue
-		}
-
-		Debug("Getting project %s (%s)\n", imp.Name, wd)
-
-		if err := VcsUpdate(imp, f.top, home, force, cache, cacheGopath, useGopath); err != nil {
-			// We can still go on just fine even if this fails.
-			Warn("Skipped getting %s: %s\n", imp.Name, err)
-			continue
-		}
-		updateCache[imp.Name] = true
-
-		// If a revision has been set use it.
-		err := VcsVersion(imp, f.top)
-		if err != nil {
-			Warn("Problem setting version on %s: %s\n", imp.Name, err)
-		}
-	}
-
-	return nil
-}
-
-// Set the references for all packages after a flatten is completed.
-func flattenSetRefs(f *flattening) {
-	Debug("Setting final version for %d dependencies.", len(f.deps))
-	for _, imp := range f.deps {
-		if err := VcsVersion(imp, f.top); err != nil {
-			Warn("Problem setting version on %s: %s (flatten)\n", imp.Name, err)
-		}
-	}
-}
-
-func mergeGlide(dir, name string, f *flattening) ([]string, bool) {
-	deps := f.deps
-	vend := f.top
-	gp := path.Join(dir, "glide.yaml")
-	if _, err := os.Stat(gp); err != nil {
-		return []string{}, false
-	}
-
-	yml, err := ioutil.ReadFile(gp)
-	if err != nil {
-		Warn("Found glide file %q, but can't read: %s", gp, err)
-		return []string{}, false
-	}
-
-	conf, err := cfg.ConfigFromYaml(yml)
-	if err != nil {
-		Warn("Found glide file %q, but can't use it: %s", gp, err)
-		return []string{}, false
-	}
-
-	Info("Found glide.yaml in %s", gp)
-
-	return mergeDeps(deps, conf.Imports, vend, f), true
-}
-
-// listGodep appends Godeps entries to the deps.
-//
-// It returns true if any dependencies were found (even if not added because
-// they are duplicates).
-func mergeGodep(dir, name string, f *flattening) ([]string, bool) {
-	deps := f.deps
-	vend := f.top
-	Debug("Looking in %s/Godeps/ for a Godeps.json file.\n", dir)
-	d, err := parseGodepGodeps(dir)
-	if err != nil {
-		Warn("Looking for Godeps: %s\n", err)
-		return []string{}, false
-	} else if len(d) == 0 {
-		return []string{}, false
-	}
-
-	Info("Found Godeps.json file for %q", name)
-	return mergeDeps(deps, d, vend, f), true
-}
-
-// listGb merges GB dependencies into the deps.
-func mergeGb(dir, pkg string, f *flattening) ([]string, bool) {
-	deps := f.deps
-	vend := f.top
-	Debug("Looking in %s/vendor/ for a manifest file.\n", dir)
-	d, err := parseGbManifest(dir)
-	if err != nil || len(d) == 0 {
-		return []string{}, false
-	}
-	Info("Found gb manifest file for %q", pkg)
-	return mergeDeps(deps, d, vend, f), true
-}
-
-// mergeGPM merges GPM Godeps files into deps.
-func mergeGPM(dir, pkg string, f *flattening) ([]string, bool) {
-	deps := f.deps
-	vend := f.top
-	d, err := parseGPMGodeps(dir)
-	if err != nil || len(d) == 0 {
-		return []string{}, false
-	}
-	Info("Found GPM file for %q", pkg)
-	return mergeDeps(deps, d, vend, f), true
-}
-
-// mergeGuess guesses dependencies and merges.
-//
-// This always returns true because it always handles the job of searching
-// for dependencies. So generally it should be the last merge strategy
-// that you try.
-func mergeGuess(dir, pkg string, f *flattening, scanned map[string]bool) ([]string, bool) {
-	deps := f.deps
-	Info("Scanning %s for dependencies.", pkg)
-	buildContext, err := util.GetBuildContext()
-	if err != nil {
-		Warn("Could not scan package %q: %s", pkg, err)
-		return []string{}, false
-	}
-
-	res := []string{}
-
-	if _, err := os.Stat(dir); err != nil {
-		Warn("Directory is missing: %s", dir)
-		return res, true
-	}
-
-	d := walkDeps(buildContext, dir, pkg)
-	for _, oname := range d {
-		if _, ok := scanned[oname]; ok {
-			//Info("===> Scanned %s already. Skipping", name)
-			continue
-		}
-		Debug("=> Scanning %s", oname)
-		name, _ := NormalizeName(oname)
-		//if _, ok := deps[name]; ok {
-		//scanned[oname] = true
-		//Debug("====> Seen %s already. Skipping", name)
-		//continue
-		//}
-		if f.conf.HasIgnore(name) {
-			Debug("==> Skipping %s because it is on the ignore list", name)
-			continue
-		}
-
-		found := findPkg(buildContext, name, dir)
-		switch found.PType {
-		case ptypeUnknown:
-			Info("==> Unknown %s (%s)", name, oname)
-			Debug("✨☆ Undownloaded dependency: %s", name)
-			repo := util.GetRootFromPackage(name)
-			nd := &cfg.Dependency{
-				Name:       name,
-				Repository: "https://" + repo,
-			}
-			deps[name] = nd
-			res = append(res, name)
-		case ptypeGoroot, ptypeCgo:
-			scanned[oname] = true
-			// Why do we break rather than continue?
-			break
-		default:
-			// We're looking for dependencies that might exist in $GOPATH
-			// but not be on vendor. We add any that are on $GOPATH.
-			if _, ok := deps[name]; !ok {
-				Debug("✨☆ GOPATH dependency: %s", name)
-				nd := &cfg.Dependency{Name: name}
-				deps[name] = nd
-				res = append(res, name)
-			}
-			scanned[oname] = true
-		}
-	}
-
-	return res, true
-}
-
-// mergeDeps merges any dependency array into deps.
-func mergeDeps(orig map[string]*cfg.Dependency, add []*cfg.Dependency, vend string, f *flattening) []string {
-	mod := []string{}
-	for _, dd := range add {
-		if f.conf.HasIgnore(dd.Name) {
-			Debug("Skipping %s because it is on the ignore list", dd.Name)
-		} else if existing, ok := orig[dd.Name]; !ok {
-			// Add it unless it's already there.
-			orig[dd.Name] = dd
-			Debug("Adding %s to the scan list", dd.Name)
-			mod = append(mod, dd.Name)
-		} else if existing.Reference == "" && dd.Reference != "" {
-			// If a nested dep has finer dependency references than outside,
-			// set the reference.
-			existing.Reference = dd.Reference
-			mod = append(mod, dd.Name)
-		} else if dd.Reference != "" && existing.Reference != "" && dd.Reference != existing.Reference {
-			// Check if one is a version and the other is a constraint. If the
-			// version is in the constraint use that.
-			dest := filepath.Join(vend, filepath.FromSlash(dd.Name))
-			repo, err := existing.GetRepo(dest)
-			if err != nil {
-				Warn("Unable to access repo for %s\n", existing.Name)
-				Info("Keeping %s %s", existing.Name, existing.Reference)
-				continue
-			}
-
-			eIsRef := repo.IsReference(existing.Reference)
-			ddIsRef := repo.IsReference(dd.Reference)
-
-			// Both are references and different ones.
-			if eIsRef && ddIsRef {
-				Warn("Conflict: %s ref is %s, but also asked for %s\n", existing.Name, existing.Reference, dd.Reference)
-				Info("Keeping %s %s", existing.Name, existing.Reference)
-			} else if eIsRef {
-				// Test ddIsRef is a constraint and if eIsRef is a semver
-				// within that
-				con, err := semver.NewConstraint(dd.Reference)
-				if err != nil {
-					Warn("Version issue for %s: '%s' is neither a reference or semantic version constraint\n", dd.Name, dd.Reference)
-					Info("Keeping %s %s", existing.Name, existing.Reference)
-					continue
-				}
-
-				ver, err := semver.NewVersion(existing.Reference)
-				if err != nil {
-					// The existing version is not a semantic version.
-					Warn("Conflict: %s version is %s, but also asked for %s\n", existing.Name, existing.Reference, dd.Reference)
-					Info("Keeping %s %s", existing.Name, existing.Reference)
-					continue
-				}
-
-				if con.Check(ver) {
-					Info("Keeping %s %s because it fits constraint '%s'", existing.Name, existing.Reference, dd.Reference)
-				} else {
-					Warn("Conflict: %s version is %s but does not meet constraint '%s'\n", existing.Name, existing.Reference, dd.Reference)
-					Info("Keeping %s %s", existing.Name, existing.Reference)
-				}
-
-			} else if ddIsRef {
-				// Test eIsRef is a constraint and if ddIsRef is a semver
-				// within that
-				con, err := semver.NewConstraint(existing.Reference)
-				if err != nil {
-					Warn("Version issue for %s: '%s' is neither a reference or semantic version constraint\n", existing.Name, existing.Reference)
-					Info("Keeping %s %s", existing.Name, existing.Reference)
-					continue
-				}
-
-				ver, err := semver.NewVersion(dd.Reference)
-				if err != nil {
-					// The dd version is not a semantic version.
-					Warn("Conflict: %s version is %s, but also asked for %s\n", existing.Name, existing.Reference, dd.Reference)
-					Info("Keeping %s %s", existing.Name, existing.Reference)
-					continue
-				}
-
-				if con.Check(ver) {
-					// Use the specific version if noted instead of the existing
-					// constraint.
-					existing.Reference = dd.Reference
-					mod = append(mod, dd.Name)
-					Info("Using %s %s because it fits constraint '%s'", existing.Name, dd.Reference, existing.Reference)
-				} else {
-					Warn("Conflict: %s semantic version constraint is %s but '%s' does not meet the constraint\n", existing.Name, existing.Reference, dd.Reference)
-					Info("Keeping %s %s", existing.Name, existing.Reference)
-				}
-			} else {
-				// Neither is a vcs reference and both could be semantic version
-				// constraints that are different.
-
-				_, err := semver.NewConstraint(dd.Reference)
-				if err != nil {
-					// dd.Reference is not a reference or a valid constraint.
-					Warn("Version %s %s is not a reference or valid semantic version constraint\n", dd.Name, dd.Reference)
-					Info("Keeping %s %s", existing.Name, existing.Reference)
-					continue
-				}
-
-				_, err = semver.NewConstraint(existing.Reference)
-				if err != nil {
-					// existing.Reference is not a reference or a valid constraint.
-					// We really should never end up here.
-					Warn("Version %s %s is not a reference or valid semantic version constraint\n", existing.Name, existing.Reference)
-
-					existing.Reference = dd.Reference
-					mod = append(mod, dd.Name)
-					Info("Using %s %s because it is a valid version", existing.Name, existing.Reference)
-					continue
-				}
-
-				// Both versions are constraints. Try to merge them.
-				// If either comparison has an || skip merging. That's complicated.
-				ddor := strings.Index(dd.Reference, "||")
-				eor := strings.Index(existing.Reference, "||")
-				if ddor == -1 && eor == -1 {
-					// Add the comparisons together.
-					newRef := existing.Reference + ", " + dd.Reference
-					existing.Reference = newRef
-					mod = append(mod, dd.Name)
-					Info("Combining %s semantic version constraints %s and %s", existing.Name, existing.Reference, dd.Reference)
-				} else {
-					Warn("Conflict: %s version is %s, but also asked for %s\n", existing.Name, existing.Reference, dd.Reference)
-					Info("Keeping %s %s", existing.Name, existing.Reference)
-				}
-			}
-		}
-	}
-	return mod
-}
diff --git a/cmd/gb.go b/cmd/gb.go
deleted file mode 100644
index e74e6b6..0000000
--- a/cmd/gb.go
+++ /dev/null
@@ -1,79 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-	"github.com/Masterminds/glide/gb"
-)
-
-func HasGbManifest(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	dir := cookoo.GetString("dir", "", p)
-	path := filepath.Join(dir, "vendor", "manifest")
-	_, err := os.Stat(path)
-	return err == nil, nil
-}
-
-// GbManifest
-//
-// Params:
-// 	- dir (string): The directory where the manifest file is located.
-// Returns:
-//
-func GbManifest(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	dir := cookoo.GetString("dir", ".", p)
-	return parseGbManifest(dir)
-}
-
-func parseGbManifest(dir string) ([]*cfg.Dependency, error) {
-	path := filepath.Join(dir, "vendor", "manifest")
-	if fi, err := os.Stat(path); err != nil || fi.IsDir() {
-		return []*cfg.Dependency{}, nil
-	}
-
-	Info("Found GB manifest file.\n")
-	buf := []*cfg.Dependency{}
-	file, err := os.Open(path)
-	if err != nil {
-		return buf, err
-	}
-	defer file.Close()
-
-	man := gb.Manifest{}
-
-	dec := json.NewDecoder(file)
-	if err := dec.Decode(&man); err != nil {
-		return buf, err
-	}
-
-	seen := map[string]bool{}
-
-	for _, d := range man.Dependencies {
-		pkg, sub := NormalizeName(d.Importpath)
-		if _, ok := seen[pkg]; ok {
-			if len(sub) == 0 {
-				continue
-			}
-			for _, dep := range buf {
-				if dep.Name == pkg {
-					dep.Subpackages = append(dep.Subpackages, sub)
-				}
-			}
-		} else {
-			seen[pkg] = true
-			dep := &cfg.Dependency{
-				Name:       pkg,
-				Reference:  d.Revision,
-				Repository: d.Repository,
-			}
-			if len(sub) > 0 {
-				dep.Subpackages = []string{sub}
-			}
-			buf = append(buf, dep)
-		}
-	}
-	return buf, nil
-}
diff --git a/cmd/get_imports.go b/cmd/get_imports.go
deleted file mode 100644
index 8613914..0000000
--- a/cmd/get_imports.go
+++ /dev/null
@@ -1,882 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"os/exec"
-	"path/filepath"
-	"sort"
-	"sync"
-	//"log"
-
-	"os"
-	"runtime"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-	"github.com/Masterminds/glide/util"
-	"github.com/Masterminds/semver"
-	v "github.com/Masterminds/vcs"
-)
-
-// Used for the fan out/in pattern used with VCS calls.
-var concurrentWorkers = 20
-
-//func init() {
-// Uncomment the line below and the log import to see the output
-// from the vcs commands executed for each project.
-//v.Logger = log.New(os.Stdout, "go-vcs", log.LstdFlags)
-//}
-
-// GetAll gets zero or more repos.
-//
-// This takes a package name, normalizes it, finds the repo, and installs it.
-// It's the workhorse behind `glide get`.
-//
-// Params:
-//	- packages ([]string): Package names to get.
-// 	- verbose (bool): default false
-//
-// Returns:
-// 	- []*Dependency: A list of constructed dependencies.
-func GetAll(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	names := p.Get("packages", []string{}).([]string)
-	conf := p.Get("conf", nil).(*cfg.Config)
-	insecure := p.Get("insecure", false).(bool)
-
-	Info("Preparing to install %d package.", len(names))
-
-	deps := []*cfg.Dependency{}
-	for _, name := range names {
-		var version string
-		parts := strings.Split(name, "#")
-		if len(parts) > 1 {
-			name = parts[0]
-			version = parts[1]
-		}
-
-		root := util.GetRootFromPackage(name)
-		if len(root) == 0 {
-			return nil, fmt.Errorf("Package name is required for %q.", name)
-		}
-
-		if conf.HasDependency(root) {
-			Warn("Package %q is already in glide.yaml. Skipping", root)
-			continue
-		}
-
-		if conf.HasIgnore(root) {
-			Warn("Package %q is set to be ignored in glide.yaml. Skipping", root)
-			continue
-		}
-
-		dep := &cfg.Dependency{
-			Name: root,
-		}
-
-		if version != "" {
-			dep.Reference = version
-		}
-
-		// When retriving from an insecure location set the repo to the
-		// insecure location.
-		if insecure {
-			dep.Repository = "http://" + root
-		}
-
-		subpkg := strings.TrimPrefix(name, root)
-		if len(subpkg) > 0 && subpkg != "/" {
-			dep.Subpackages = []string{subpkg}
-		}
-
-		if dep.Reference != "" {
-			Info("Importing %s with the version %s", dep.Name, dep.Reference)
-		} else {
-			Info("Importing %s", dep.Name)
-		}
-
-		conf.Imports = append(conf.Imports, dep)
-
-		deps = append(deps, dep)
-
-	}
-
-	Info("Walking the dependency tree to calculate versions")
-	return deps, nil
-}
-
-// UpdateImports iterates over the imported packages and updates them.
-//
-// Params:
-//
-// 	- force (bool): force packages to update (default false)
-//	- conf (*cfg.Config): The configuration
-// 	- packages([]string): The packages to update. Default is all.
-func UpdateImports(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	cfg := p.Get("conf", nil).(*cfg.Config)
-	force := p.Get("force", true).(bool)
-	plist := p.Get("packages", []string{}).([]string)
-	home := p.Get("home", "").(string)
-	cache := p.Get("cache", false).(bool)
-	cacheGopath := p.Get("cacheGopath", false).(bool)
-	useGopath := p.Get("useGopath", false).(bool)
-
-	pkgs := list2map(plist)
-	restrict := len(pkgs) > 0
-
-	cwd, err := VendorPath(c)
-	if err != nil {
-		return false, err
-	}
-
-	if len(cfg.Imports) == 0 {
-		Info("No dependencies found. Nothing updated.\n")
-		return false, nil
-	}
-
-	for _, dep := range cfg.Imports {
-		if restrict && !pkgs[dep.Name] {
-			Debug("===> Skipping %q", dep.Name)
-
-			// Even though skipping check if the package exists and has VCS info
-			// needed for other operations.
-			dest := filepath.Join(cwd, filepath.FromSlash(dep.Name))
-			if _, err := os.Stat(dest); os.IsNotExist(err) {
-				Warn("Package %s not checked out to vendor/ folder", dep.Name)
-				Error("Unable to generate accurate glide.lock because %s is missing", dep.Name)
-			} else {
-				empty, err := isDirectoryEmpty(dest)
-				_, err2 := v.DetectVcsFromFS(dest)
-				if err != nil || empty == true {
-					Warn("Package %s not checked out to vendor/ folder. Directory empty", dep.Name)
-					Error("Unable to generate accurate glide.lock because %s is missing", dep.Name)
-					continue
-				} else if empty == false && err2 == v.ErrCannotDetectVCS {
-					Warn("%s appears to be a vendored package missing version control data", dep.Name)
-					Error("Unable to generate accurate glide.lock because %s version control data is missing", dep.Name)
-				}
-			}
-
-			continue
-		}
-
-		// Hack: The updateCache global keeps us from re-updating the same
-		// dependencies when we're recursing. We cache here to prevent
-		// flattening from causing unnecessary updates.
-		updateCache[dep.Name] = true
-
-		if err := VcsUpdate(dep, cwd, home, force, cache, cacheGopath, useGopath); err != nil {
-			Warn("Update failed for %s: %s\n", dep.Name, err)
-		}
-	}
-
-	return true, nil
-}
-
-// SetReference is a command to set the VCS reference (commit id, tag, etc) for
-// a project.
-func SetReference(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	conf := p.Get("conf", nil).(*cfg.Config)
-	cwd, err := VendorPath(c)
-	if err != nil {
-		return false, err
-	}
-
-	if len(conf.Imports) == 0 {
-		Info("No references set.\n")
-		return false, nil
-	}
-	//
-	// for _, dep := range conf.Imports {
-	// 	if err := VcsVersion(dep, cwd); err != nil {
-	// 		Warn("Failed to set version on %s to %s: %s\n", dep.Name, dep.Reference, err)
-	// 	}
-	// }
-
-	done := make(chan struct{}, concurrentWorkers)
-	in := make(chan *cfg.Dependency, concurrentWorkers)
-	var wg sync.WaitGroup
-
-	for i := 0; i < concurrentWorkers; i++ {
-		go func(ch <-chan *cfg.Dependency) {
-			for {
-				select {
-				case dep := <-ch:
-					if err := VcsVersion(dep, cwd); err != nil {
-						Warn("Failed to set version on %s to %s: %s\n", dep.Name, dep.Reference, err)
-					}
-					wg.Done()
-				case <-done:
-					return
-				}
-			}
-		}(in)
-	}
-
-	for _, dep := range conf.Imports {
-		wg.Add(1)
-		in <- dep
-	}
-
-	wg.Wait()
-	// Close goroutines setting the version
-	for i := 0; i < concurrentWorkers; i++ {
-		done <- struct{}{}
-	}
-	// close(done)
-	// close(in)
-
-	return true, nil
-}
-
-// filterArchOs indicates a dependency should be filtered out because it is
-// the wrong GOOS or GOARCH.
-func filterArchOs(dep *cfg.Dependency) bool {
-	found := false
-	if len(dep.Arch) > 0 {
-		for _, a := range dep.Arch {
-			if a == runtime.GOARCH {
-				found = true
-			}
-		}
-		// If it's not found, it should be filtered out.
-		if !found {
-			return true
-		}
-	}
-
-	found = false
-	if len(dep.Os) > 0 {
-		for _, o := range dep.Os {
-			if o == runtime.GOOS {
-				found = true
-			}
-		}
-		if !found {
-			return true
-		}
-
-	}
-
-	return false
-}
-
-// VcsExists checks if the directory has a local VCS checkout.
-func VcsExists(dep *cfg.Dependency, dest string) bool {
-	repo, err := dep.GetRepo(dest)
-	if err != nil {
-		return false
-	}
-
-	return repo.CheckLocal()
-}
-
-// VcsGet figures out how to fetch a dependency, and then gets it.
-//
-// VcsGet installs into the dest.
-func VcsGet(dep *cfg.Dependency, dest, home string, cache, cacheGopath, useGopath bool) error {
-	// When not skipping the $GOPATH look in it for a copy of the package
-	if useGopath {
-		// Check if the $GOPATH has a viable version to use and if so copy to vendor
-		gps := Gopaths()
-		for _, p := range gps {
-			d := filepath.Join(p, "src", filepath.FromSlash(dep.Name))
-			if _, err := os.Stat(d); err == nil {
-				empty, err := isDirectoryEmpty(d)
-				if empty || err != nil {
-					continue
-				}
-
-				repo, err := dep.GetRepo(d)
-				if err != nil {
-					continue
-				}
-
-				// Dirty repos have uncomitted changes.
-				if repo.IsDirty() {
-					continue
-				}
-
-				// Having found a repo we copy it to vendor and update it.
-				Debug("Found %s in GOPATH at %s. Copying to %s", dep.Name, d, dest)
-				err = copyDir(d, dest)
-				if err != nil {
-					return err
-				}
-
-				// Update the repo in the vendor directory
-				Debug("Updating %s, now in the vendor path at %s", dep.Name, dest)
-				repo, err = dep.GetRepo(dest)
-				if err != nil {
-					return err
-				}
-				err = repo.Update()
-				if err != nil {
-					return err
-				}
-
-				// If there is no reference set on the dep we try to checkout
-				// the default branch.
-				if dep.Reference == "" {
-					db := defaultBranch(repo, home)
-					if db != "" {
-						err = repo.UpdateVersion(db)
-						if err != nil {
-							Debug("Attempting to set the version on %s to %s failed. Error %s", dep.Name, db, err)
-						}
-					}
-				}
-				return nil
-			}
-		}
-	}
-
-	// When opting in to cache in the GOPATH attempt to do put a copy there.
-	if cacheGopath {
-
-		// Since we didn't find an existing copy in the GOPATHs try to clone there.
-		gp := Gopath()
-		if gp != "" {
-			d := filepath.Join(gp, "src", filepath.FromSlash(dep.Name))
-			if _, err := os.Stat(d); os.IsNotExist(err) {
-				// Empty directory so we checkout out the code here.
-				Debug("Retrieving %s to %s before copying to vendor", dep.Name, d)
-				repo, err := dep.GetRepo(d)
-				if err != nil {
-					return err
-				}
-				repo.Get()
-
-				branch := findCurrentBranch(repo)
-				if branch != "" {
-					// we know the default branch so we can store it in the cache
-					var loc string
-					if dep.Repository != "" {
-						loc = dep.Repository
-					} else {
-						loc = "https://" + dep.Name
-					}
-					key, err := cacheCreateKey(loc)
-					if err == nil {
-						Debug("Saving default branch for %s", repo.Remote())
-						c := cacheRepoInfo{DefaultBranch: branch}
-						err = saveCacheRepoData(key, c, home)
-						if err == errCacheDisabled {
-							Debug("Unable to cache default branch because caching is disabled")
-						}
-					}
-				}
-
-				Debug("Copying %s from GOPATH at %s to %s", dep.Name, d, dest)
-				err = copyDir(d, dest)
-				if err != nil {
-					return err
-				}
-
-				return nil
-			}
-		}
-	}
-
-	// If opting in to caching attempt to put it in the cache folder
-	if cache {
-		// Check if the cache has a viable version and try to use that.
-		var loc string
-		if dep.Repository != "" {
-			loc = dep.Repository
-		} else {
-			loc = "https://" + dep.Name
-		}
-		key, err := cacheCreateKey(loc)
-		if err == nil {
-			d := filepath.Join(home, "cache", "src", key)
-
-			repo, err := dep.GetRepo(d)
-			if err != nil {
-				return err
-			}
-			// If the directory does not exist this is a first cache.
-			if _, err = os.Stat(d); os.IsNotExist(err) {
-				Debug("Adding %s to the cache for the first time", dep.Name)
-				err = repo.Get()
-				if err != nil {
-					return err
-				}
-				branch := findCurrentBranch(repo)
-				if branch != "" {
-					// we know the default branch so we can store it in the cache
-					var loc string
-					if dep.Repository != "" {
-						loc = dep.Repository
-					} else {
-						loc = "https://" + dep.Name
-					}
-					key, err := cacheCreateKey(loc)
-					if err == nil {
-						Debug("Saving default branch for %s", repo.Remote())
-						c := cacheRepoInfo{DefaultBranch: branch}
-						err = saveCacheRepoData(key, c, home)
-						if err == errCacheDisabled {
-							Debug("Unable to cache default branch because caching is disabled")
-						} else if err != nil {
-							Debug("Error saving %s to cache. Error: %s", repo.Remote(), err)
-						}
-					}
-				}
-
-			} else {
-				Debug("Updating %s in the cache", dep.Name)
-				err = repo.Update()
-				if err != nil {
-					return err
-				}
-			}
-
-			Debug("Copying %s from the cache to %s", dep.Name, dest)
-			err = copyDir(d, dest)
-			if err != nil {
-				return err
-			}
-
-			return nil
-		} else {
-			Warn("Cache key generation error: %s", err)
-		}
-	}
-
-	// If unable to cache pull directly into the vendor/ directory.
-	repo, err := dep.GetRepo(dest)
-	if err != nil {
-		return err
-	}
-
-	gerr := repo.Get()
-
-	// Attempt to cache the default branch
-	branch := findCurrentBranch(repo)
-	if branch != "" {
-		// we know the default branch so we can store it in the cache
-		var loc string
-		if dep.Repository != "" {
-			loc = dep.Repository
-		} else {
-			loc = "https://" + dep.Name
-		}
-		key, err := cacheCreateKey(loc)
-		if err == nil {
-			Debug("Saving default branch for %s", repo.Remote())
-			c := cacheRepoInfo{DefaultBranch: branch}
-			err = saveCacheRepoData(key, c, home)
-			if err == errCacheDisabled {
-				Debug("Unable to cache default branch because caching is disabled")
-			} else if err != nil {
-				Debug("Error saving %s to cache - Error: %s", repo.Remote(), err)
-			}
-		}
-	}
-
-	return gerr
-}
-
-// VcsUpdate updates to a particular checkout based on the VCS setting.
-func VcsUpdate(dep *cfg.Dependency, vend, home string, force, cache, cacheGopath, useGopath bool) error {
-	Info("Fetching updates for %s.\n", dep.Name)
-
-	if filterArchOs(dep) {
-		Info("%s is not used for %s/%s.\n", dep.Name, runtime.GOOS, runtime.GOARCH)
-		return nil
-	}
-
-	dest := filepath.Join(vend, filepath.FromSlash(dep.Name))
-	// If destination doesn't exist we need to perform an initial checkout.
-	if _, err := os.Stat(dest); os.IsNotExist(err) {
-		if err = VcsGet(dep, dest, home, cache, cacheGopath, useGopath); err != nil {
-			Warn("Unable to checkout %s\n", dep.Name)
-			return err
-		}
-	} else {
-		// At this point we have a directory for the package.
-
-		// When the directory is not empty and has no VCS directory it's
-		// a vendored files situation.
-		empty, err := isDirectoryEmpty(dest)
-		if err != nil {
-			return err
-		}
-		_, err = v.DetectVcsFromFS(dest)
-		if updatingVendored == false && empty == false && err == v.ErrCannotDetectVCS {
-			Warn("%s appears to be a vendored package. Unable to update. Consider the '--update-vendored' flag.\n", dep.Name)
-		} else {
-
-			if updatingVendored == true && empty == false && err == v.ErrCannotDetectVCS {
-				// A vendored package, no repo, and updating the vendored packages
-				// has been opted into.
-				Info("%s is a vendored package. Updating.", dep.Name)
-				err = os.RemoveAll(dest)
-				if err != nil {
-					Error("Unable to update vendored dependency %s.\n", dep.Name)
-					return err
-				} else {
-					dep.UpdateAsVendored = true
-				}
-
-				if err = VcsGet(dep, dest, home, cache, cacheGopath, useGopath); err != nil {
-					Warn("Unable to checkout %s\n", dep.Name)
-					return err
-				}
-
-				return nil
-			}
-
-			repo, err := dep.GetRepo(dest)
-
-			// Tried to checkout a repo to a path that does not work. Either the
-			// type or endpoint has changed. Force is being passed in so the old
-			// location can be removed and replaced with the new one.
-			// Warning, any changes in the old location will be deleted.
-			// TODO: Put dirty checking in on the existing local checkout.
-			if (err == v.ErrWrongVCS || err == v.ErrWrongRemote) && force == true {
-				var newRemote string
-				if len(dep.Repository) > 0 {
-					newRemote = dep.Repository
-				} else {
-					newRemote = "https://" + dep.Name
-				}
-
-				Warn("Replacing %s with contents from %s\n", dep.Name, newRemote)
-				rerr := os.RemoveAll(dest)
-				if rerr != nil {
-					return rerr
-				}
-				if err = VcsGet(dep, dest, home, cache, cacheGopath, useGopath); err != nil {
-					Warn("Unable to checkout %s\n", dep.Name)
-					return err
-				}
-			} else if err != nil {
-				return err
-			} else if repo.IsDirty() {
-				return fmt.Errorf("%s contains uncommited changes. Skipping update", dep.Name)
-			} else {
-
-				// Check if the current version is a tag or commit id. If it is
-				// and that version is already checked out we can skip updating
-				// which is faster than going out to the Internet to perform
-				// an update.
-				if dep.Reference != "" {
-					version, err := repo.Version()
-					if err != nil {
-						return err
-					}
-					ib, err := isBranch(dep.Reference, repo)
-					if err != nil {
-						return err
-					}
-
-					// If the current version equals the ref and it's not a
-					// branch it's a tag or commit id so we can skip
-					// performing an update.
-					if version == dep.Reference && !ib {
-						Info("%s is already set to version %s. Skipping update.", dep.Name, dep.Reference)
-						return nil
-					}
-				}
-
-				if err := repo.Update(); err != nil {
-					Warn("Download failed.\n")
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-// VcsVersion set the VCS version for a checkout.
-func VcsVersion(dep *cfg.Dependency, vend string) error {
-	cwd := filepath.Join(vend, filepath.FromSlash(dep.Name))
-
-	// If there is no refernece configured there is nothing to set.
-	if dep.Reference == "" {
-		// Before exiting update the pinned version
-		repo, err := dep.GetRepo(cwd)
-		if err != nil {
-			return err
-		}
-		dep.Pin, err = repo.Version()
-		if err != nil {
-			return err
-		}
-		return nil
-	}
-
-	// When the directory is not empty and has no VCS directory it's
-	// a vendored files situation.
-	empty, err := isDirectoryEmpty(cwd)
-	if err != nil {
-		return err
-	}
-	_, err = v.DetectVcsFromFS(cwd)
-	if empty == false && err == v.ErrCannotDetectVCS {
-		Warn("%s appears to be a vendored package. Unable to set new version. Consider the '--update-vendored' flag.\n", dep.Name)
-	} else {
-		repo, err := dep.GetRepo(cwd)
-		if err != nil {
-			return err
-		}
-
-		ver := dep.Reference
-		// Referenes in Git can begin with a ^ which is similar to semver.
-		// If there is a ^ prefix we assume it's a semver constraint rather than
-		// part of the git/VCS commit id.
-		if repo.IsReference(ver) && !strings.HasPrefix(ver, "^") {
-			Info("Setting version for %s to %s.\n", dep.Name, ver)
-		} else {
-
-			// Create the constraing first to make sure it's valid before
-			// working on the repo.
-			constraint, err := semver.NewConstraint(ver)
-
-			// Make sure the constriant is valid. At this point it's not a valid
-			// reference so if it's not a valid constrint we can exit early.
-			if err != nil {
-				Warn("The reference '%s' is not valid\n", ver)
-				return err
-			}
-
-			// Get the tags and branches (in that order)
-			refs, err := getAllVcsRefs(repo)
-			if err != nil {
-				return err
-			}
-
-			// Convert and filter the list to semver.Version instances
-			semvers := getSemVers(refs)
-
-			// Sort semver list
-			sort.Sort(sort.Reverse(semver.Collection(semvers)))
-			found := false
-			for _, v := range semvers {
-				if constraint.Check(v) {
-					found = true
-					// If the constrint passes get the original reference
-					ver = v.Original()
-					break
-				}
-			}
-			if found {
-				Info("Detected semantic version. Setting version for %s to %s.\n", dep.Name, ver)
-			} else {
-				Warn("Unable to find semantic version for constraint %s %s\n", dep.Name, ver)
-			}
-		}
-		if err := repo.UpdateVersion(ver); err != nil {
-			Error("Failed to set version to %s: %s\n", dep.Reference, err)
-			return err
-		}
-		dep.Pin, err = repo.Version()
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// VcsLastCommit gets the last commit ID from the given dependency.
-func VcsLastCommit(dep *cfg.Dependency, vend string) (string, error) {
-	cwd := filepath.Join(vend, filepath.FromSlash(dep.Name))
-	repo, err := dep.GetRepo(cwd)
-	if err != nil {
-		return "", err
-	}
-
-	if repo.CheckLocal() == false {
-		return "", fmt.Errorf("%s is not a VCS repo\n", dep.Name)
-	}
-
-	version, err := repo.Version()
-	if err != nil {
-		return "", err
-	}
-
-	return version, nil
-}
-
-// Some repos will have multiple branches in them (e.g. Git) while others
-// (e.g. Svn) will not.
-func defaultBranch(repo v.Repo, home string) string {
-
-	// Svn and Bzr use different locations (paths or entire locations)
-	// for branches so we won't have a default branch.
-	if repo.Vcs() == v.Svn || repo.Vcs() == v.Bzr {
-		return ""
-	}
-
-	// Check the cache for a value.
-	key, kerr := cacheCreateKey(repo.Remote())
-	var d cacheRepoInfo
-	if kerr == nil {
-		d, err := cacheRepoData(key, home)
-		if err == nil {
-			if d.DefaultBranch != "" {
-				return d.DefaultBranch
-			}
-		}
-	}
-
-	// If we don't have it in the store try some APIs
-	r := repo.Remote()
-	u, err := url.Parse(r)
-	if err != nil {
-		return ""
-	}
-	if u.Scheme == "" {
-		// Where there is no scheme we try urls like git@github.com:foo/bar
-		r = strings.Replace(r, ":", "/", -1)
-		r = "ssh://" + r
-		u, err = url.Parse(r)
-		if err != nil {
-			return ""
-		}
-		u.Scheme = ""
-	}
-	if u.Host == "github.com" {
-		parts := strings.Split(u.Path, "/")
-		if len(parts) != 2 {
-			return ""
-		}
-		api := fmt.Sprintf("https://api.github.com/repos/%s/%s", parts[0], parts[1])
-		resp, err := http.Get(api)
-		if err != nil {
-			return ""
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode >= 300 || resp.StatusCode < 200 {
-			return ""
-		}
-		body, err := ioutil.ReadAll(resp.Body)
-		var data interface{}
-		err = json.Unmarshal(body, &data)
-		if err != nil {
-			return ""
-		}
-		gh := data.(map[string]interface{})
-		db := gh["default_branch"].(string)
-		if kerr == nil {
-			d.DefaultBranch = db
-			err := saveCacheRepoData(key, d, home)
-			if err == errCacheDisabled {
-				Debug("Unable to cache default branch because caching is disabled")
-			} else if err != nil {
-				Debug("Error saving %s to cache. Error: %s", repo.Remote(), err)
-			}
-		}
-		return db
-	}
-
-	if u.Host == "bitbucket.org" {
-		parts := strings.Split(u.Path, "/")
-		if len(parts) != 2 {
-			return ""
-		}
-		api := fmt.Sprintf("https://bitbucket.org/api/1.0/repositories/%s/%s/main-branch/", parts[0], parts[1])
-		resp, err := http.Get(api)
-		if err != nil {
-			return ""
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode >= 300 || resp.StatusCode < 200 {
-			return ""
-		}
-		body, err := ioutil.ReadAll(resp.Body)
-		var data interface{}
-		err = json.Unmarshal(body, &data)
-		if err != nil {
-			return ""
-		}
-		bb := data.(map[string]interface{})
-		db := bb["name"].(string)
-		if kerr == nil {
-			d.DefaultBranch = db
-			err := saveCacheRepoData(key, d, home)
-			if err == errCacheDisabled {
-				Debug("Unable to cache default branch because caching is disabled")
-			} else if err != nil {
-				Debug("Error saving %s to cache. Error: %s", repo.Remote(), err)
-			}
-		}
-		return db
-	}
-
-	return ""
-}
-
-// From a local repo find out the current branch name if there is one.
-func findCurrentBranch(repo v.Repo) string {
-	Debug("Attempting to find current branch for %s", repo.Remote())
-	// Svn and Bzr don't have default branches.
-	if repo.Vcs() == v.Svn || repo.Vcs() == v.Bzr {
-		return ""
-	}
-
-	if repo.Vcs() == v.Git {
-		c := exec.Command("git", "symbolic-ref", "--short", "HEAD")
-		c.Dir = repo.LocalPath()
-		c.Env = envForDir(c.Dir)
-		out, err := c.CombinedOutput()
-		if err != nil {
-			Debug("Unable to find current branch for %s, error: %s", repo.Remote(), err)
-			return ""
-		}
-		return strings.TrimSpace(string(out))
-	}
-
-	if repo.Vcs() == v.Hg {
-		c := exec.Command("hg", "branch")
-		c.Dir = repo.LocalPath()
-		c.Env = envForDir(c.Dir)
-		out, err := c.CombinedOutput()
-		if err != nil {
-			Debug("Unable to find current branch for %s, error: %s", repo.Remote(), err)
-			return ""
-		}
-		return strings.TrimSpace(string(out))
-	}
-
-	return ""
-}
-
-// list2map takes a list of packages names and creates a map of normalized names.
-func list2map(in []string) map[string]bool {
-	out := make(map[string]bool, len(in))
-	for _, v := range in {
-		v, _ := NormalizeName(v)
-		out[v] = true
-	}
-	return out
-}
-
-func envForDir(dir string) []string {
-	env := os.Environ()
-	return mergeEnvLists([]string{"PWD=" + dir}, env)
-}
-
-func mergeEnvLists(in, out []string) []string {
-NextVar:
-	for _, inkv := range in {
-		k := strings.SplitAfterN(inkv, "=", 2)[0]
-		for i, outkv := range out {
-			if strings.HasPrefix(outkv, k) {
-				out[i] = inkv
-				continue NextVar
-			}
-		}
-		out = append(out, inkv)
-	}
-	return out
-}
diff --git a/cmd/get_imports_test.go b/cmd/get_imports_test.go
deleted file mode 100644
index b072ed4..0000000
--- a/cmd/get_imports_test.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package cmd
-
-import "github.com/Masterminds/cookoo"
-
-func SilenceLogs(c cookoo.Context) {
-	p := cookoo.NewParamsWithValues(map[string]interface{}{"quiet": true})
-	BeQuiet(c, p)
-}
diff --git a/cmd/gpm.go b/cmd/gpm.go
deleted file mode 100644
index eef097f..0000000
--- a/cmd/gpm.go
+++ /dev/null
@@ -1,110 +0,0 @@
-package cmd
-
-import (
-	"bufio"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-)
-
-// This file contains commands for working with GPM/GVP.
-
-// HasGPMGodeps indicates whether a Godeps file exists.
-func HasGPMGodeps(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	dir := cookoo.GetString("dir", "", p)
-	path := filepath.Join(dir, "Godeps")
-	_, err := os.Stat(path)
-	return err == nil, nil
-}
-
-// GPMGodeps parses a GPM-flavored Godeps file.
-//
-// Params
-// 	- dir (string): Directory root.
-//
-// Returns an []*cfg.Dependency
-func GPMGodeps(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	dir := cookoo.GetString("dir", "", p)
-	return parseGPMGodeps(dir)
-}
-func parseGPMGodeps(dir string) ([]*cfg.Dependency, error) {
-	path := filepath.Join(dir, "Godeps")
-	if i, err := os.Stat(path); err != nil {
-		return []*cfg.Dependency{}, nil
-	} else if i.IsDir() {
-		Info("Godeps is a directory. This is probably a Godep project.\n")
-		return []*cfg.Dependency{}, nil
-	}
-	Info("Found Godeps file.\n")
-
-	buf := []*cfg.Dependency{}
-
-	file, err := os.Open(path)
-	if err != nil {
-		return buf, err
-	}
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		parts, ok := parseGodepsLine(scanner.Text())
-		if ok {
-			dep := &cfg.Dependency{Name: parts[0]}
-			if len(parts) > 1 {
-				dep.Reference = parts[1]
-			}
-			buf = append(buf, dep)
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		Warn("Scan failed: %s\n", err)
-		return buf, err
-	}
-
-	return buf, nil
-}
-
-// GPMGodepsGit reads a Godeps-Git file for gpm-git.
-func GPMGodepsGit(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	dir := cookoo.GetString("dir", "", p)
-	path := filepath.Join(dir, "Godeps-Git")
-	if _, err := os.Stat(path); err != nil {
-		return []*cfg.Dependency{}, nil
-	}
-	Info("Found Godeps-Git file.\n")
-
-	buf := []*cfg.Dependency{}
-
-	file, err := os.Open(path)
-	if err != nil {
-		return buf, err
-	}
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		parts, ok := parseGodepsLine(scanner.Text())
-		if ok {
-			dep := &cfg.Dependency{Name: parts[1], Repository: parts[0]}
-			if len(parts) > 2 {
-				dep.Reference = parts[2]
-			}
-			buf = append(buf, dep)
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		Warn("Scan failed: %s\n", err)
-		return buf, err
-	}
-
-	return buf, nil
-}
-
-func parseGodepsLine(line string) ([]string, bool) {
-	line = strings.TrimSpace(line)
-
-	if len(line) == 0 || strings.HasPrefix(line, "#") {
-		return []string{}, false
-	}
-
-	return strings.Fields(line), true
-}
diff --git a/cmd/guess_deps.go b/cmd/guess_deps.go
deleted file mode 100644
index 1ab3ebc..0000000
--- a/cmd/guess_deps.go
+++ /dev/null
@@ -1,169 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-	"github.com/Masterminds/glide/dependency"
-	"github.com/Masterminds/glide/util"
-)
-
-// GuessDeps tries to get the dependencies for the current directory.
-//
-// Params
-//  - dirname (string): Directory to use as the base. Default: "."
-//  - skipImport (book): Whether to skip importing from Godep, GPM, and gb
-func GuessDeps(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	buildContext, err := util.GetBuildContext()
-	if err != nil {
-		return nil, err
-	}
-	base := p.Get("dirname", ".").(string)
-	skipImport := p.Get("skipImport", false).(bool)
-	name := guessPackageName(buildContext, base)
-
-	Info("Generating a YAML configuration file and guessing the dependencies")
-
-	config := new(cfg.Config)
-
-	// Get the name of the top level package
-	config.Name = name
-
-	// Import by looking at other package managers and looking over the
-	// entire directory structure.
-
-	// Attempt to import from other package managers.
-	if !skipImport {
-		Info("Attempting to import from other package managers (use --skip-import to skip)")
-		deps := []*cfg.Dependency{}
-		absBase, err := filepath.Abs(base)
-		if err != nil {
-			return nil, err
-		}
-
-		if d, ok := guessImportGodep(absBase); ok {
-			Info("Importing Godep configuration")
-			Warn("Godep uses commit id versions. Consider using Semantic Versions with Glide")
-			deps = d
-		} else if d, ok := guessImportGPM(absBase); ok {
-			Info("Importing GPM configuration")
-			deps = d
-		} else if d, ok := guessImportGB(absBase); ok {
-			Info("Importing GB configuration")
-			deps = d
-		}
-
-		for _, i := range deps {
-			Info("Found imported reference to %s\n", i.Name)
-			config.Imports = append(config.Imports, i)
-		}
-	}
-
-	// Resolve dependencies by looking at the tree.
-	r, err := dependency.NewResolver(base)
-	if err != nil {
-		return nil, err
-	}
-
-	h := &dependency.DefaultMissingPackageHandler{Missing: []string{}, Gopath: []string{}}
-	r.Handler = h
-
-	sortable, err := r.ResolveLocal(false)
-	if err != nil {
-		return nil, err
-	}
-
-	sort.Strings(sortable)
-
-	vpath := r.VendorDir
-	if !strings.HasSuffix(vpath, "/") {
-		vpath = vpath + string(os.PathSeparator)
-	}
-
-	for _, pa := range sortable {
-		n := strings.TrimPrefix(pa, vpath)
-		root := util.GetRootFromPackage(n)
-
-		if !config.HasDependency(root) {
-			Info("Found reference to %s\n", n)
-			d := &cfg.Dependency{
-				Name: root,
-			}
-			subpkg := strings.TrimPrefix(n, root)
-			if len(subpkg) > 0 && subpkg != "/" {
-				d.Subpackages = []string{subpkg}
-			}
-			config.Imports = append(config.Imports, d)
-		} else {
-			subpkg := strings.TrimPrefix(n, root)
-			if len(subpkg) > 0 && subpkg != "/" {
-				subpkg = strings.TrimPrefix(subpkg, "/")
-				d := config.Imports.Get(root)
-				f := false
-				for _, v := range d.Subpackages {
-					if v == subpkg {
-						f = true
-					}
-				}
-				if !f {
-					Info("Adding sub-package %s to %s\n", subpkg, root)
-					d.Subpackages = append(d.Subpackages, subpkg)
-				}
-			}
-		}
-	}
-
-	return config, nil
-}
-
-// Attempt to guess at the package name at the top level. When unable to detect
-// a name goes to default of "main".
-func guessPackageName(b *util.BuildCtxt, base string) string {
-	cwd, err := os.Getwd()
-	if err != nil {
-		return "main"
-	}
-
-	pkg, err := b.Import(base, cwd, 0)
-	if err != nil {
-		// There may not be any top level Go source files but the project may
-		// still be within the GOPATH.
-		if strings.HasPrefix(base, b.GOPATH) {
-			p := strings.TrimPrefix(base, b.GOPATH)
-			return strings.Trim(p, string(os.PathSeparator))
-		}
-	}
-
-	return pkg.ImportPath
-}
-
-func guessImportGodep(dir string) ([]*cfg.Dependency, bool) {
-	d, err := parseGodepGodeps(dir)
-	if err != nil || len(d) == 0 {
-		return []*cfg.Dependency{}, false
-	}
-
-	return d, true
-}
-
-func guessImportGPM(dir string) ([]*cfg.Dependency, bool) {
-	d, err := parseGPMGodeps(dir)
-	if err != nil || len(d) == 0 {
-		return []*cfg.Dependency{}, false
-	}
-
-	return d, true
-}
-
-func guessImportGB(dir string) ([]*cfg.Dependency, bool) {
-	d, err := parseGbManifest(dir)
-	if err != nil || len(d) == 0 {
-		return []*cfg.Dependency{}, false
-	}
-
-	return d, true
-}
diff --git a/cmd/install.go b/cmd/install.go
deleted file mode 100644
index ea4b86a..0000000
--- a/cmd/install.go
+++ /dev/null
@@ -1,142 +0,0 @@
-package cmd
-
-import (
-	"io/ioutil"
-	"os"
-	"sync"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-)
-
-// LockFileExists checks if a lock file exists. If not it jumps to the update
-// command.
-func LockFileExists(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	fname := p.Get("filename", "glide.lock").(string)
-	if _, err := os.Stat(fname); err != nil {
-		Info("Lock file (glide.lock) does not exist. Performing update.")
-		return false, &cookoo.Reroute{"update"}
-	}
-
-	return true, nil
-}
-
-// LoadLockFile loads the lock file to the context and checks if it is correct
-// for the loaded cfg file.
-func LoadLockFile(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	fname := p.Get("filename", "glide.lock").(string)
-	conf := p.Get("conf", nil).(*cfg.Config)
-
-	yml, err := ioutil.ReadFile(fname)
-	if err != nil {
-		return nil, err
-	}
-	lock, err := cfg.LockfileFromYaml(yml)
-	if err != nil {
-		return nil, err
-	}
-
-	hash, err := conf.Hash()
-	if err != nil {
-		return nil, err
-	}
-
-	if hash != lock.Hash {
-		Warn("Lock file may be out of date. Hash check of YAML failed. You may need to run 'update'")
-	}
-
-	return lock, nil
-}
-
-// Install installs the dependencies from a Lockfile.
-func Install(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	lock := p.Get("lock", nil).(*cfg.Lockfile)
-	conf := p.Get("conf", nil).(*cfg.Config)
-	force := p.Get("force", true).(bool)
-	home := p.Get("home", "").(string)
-	cache := p.Get("cache", false).(bool)
-	cacheGopath := p.Get("cacheGopath", false).(bool)
-	useGopath := p.Get("useGopath", false).(bool)
-
-	cwd, err := VendorPath(c)
-	if err != nil {
-		return false, err
-	}
-
-	// Create a config setup based on the Lockfile data to process with
-	// existing commands.
-	newConf := &cfg.Config{}
-	newConf.Name = conf.Name
-
-	newConf.Imports = make(cfg.Dependencies, len(lock.Imports))
-	for k, v := range lock.Imports {
-		newConf.Imports[k] = &cfg.Dependency{
-			Name:        v.Name,
-			Reference:   v.Version,
-			Repository:  v.Repository,
-			VcsType:     v.VcsType,
-			Subpackages: v.Subpackages,
-			Arch:        v.Arch,
-			Os:          v.Os,
-		}
-	}
-
-	newConf.DevImports = make(cfg.Dependencies, len(lock.DevImports))
-	for k, v := range lock.DevImports {
-		newConf.DevImports[k] = &cfg.Dependency{
-			Name:        v.Name,
-			Reference:   v.Version,
-			Repository:  v.Repository,
-			VcsType:     v.VcsType,
-			Subpackages: v.Subpackages,
-			Arch:        v.Arch,
-			Os:          v.Os,
-		}
-	}
-
-	newConf.DeDupe()
-
-	if len(newConf.Imports) == 0 {
-		Info("No dependencies found. Nothing installed.\n")
-		return false, nil
-	}
-
-	// for _, dep := range newConf.Imports {
-	// 	if err := VcsUpdate(dep, cwd, home, force, cache, cacheGopath, useGopath); err != nil {
-	// 		Warn("Update failed for %s: %s\n", dep.Name, err)
-	// 	}
-	// }
-
-	done := make(chan struct{}, concurrentWorkers)
-	in := make(chan *cfg.Dependency, concurrentWorkers)
-	var wg sync.WaitGroup
-
-	for i := 0; i < concurrentWorkers; i++ {
-		go func(ch <-chan *cfg.Dependency) {
-			for {
-				select {
-				case dep := <-ch:
-					if err := VcsUpdate(dep, cwd, home, force, cache, cacheGopath, useGopath); err != nil {
-						Warn("Update failed for %s: %s\n", dep.Name, err)
-					}
-					wg.Done()
-				case <-done:
-					return
-				}
-			}
-		}(in)
-	}
-
-	for _, dep := range newConf.Imports {
-		wg.Add(1)
-		in <- dep
-	}
-
-	wg.Wait()
-	// Close goroutines setting the version
-	for i := 0; i < concurrentWorkers; i++ {
-		done <- struct{}{}
-	}
-
-	return newConf, nil
-}
diff --git a/cmd/link_package.go b/cmd/link_package.go
deleted file mode 100644
index 214b094..0000000
--- a/cmd/link_package.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-)
-
-// LinkPackage creates a symlink to the project within the GOPATH.
-func LinkPackage(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	conf := c.Get("cfg", "").(*cfg.Config)
-	pname := p.Get("path", conf.Name).(string)
-
-	// Per issue #10, this may be nicer to work with in cases where repos are
-	// moved.
-	//here := "../.."
-	depth := strings.Count(pname, "/")
-	here := "../.." + strings.Repeat("/..", depth)
-
-	gopath := Gopath()
-	if gopath == "" {
-		return nil, fmt.Errorf("$GOPATH appears to be unset")
-	}
-	if len(pname) == 0 {
-		return nil, fmt.Errorf("glide.yaml is missing 'package:'")
-	}
-
-	base := path.Dir(pname)
-	if base != "." {
-		dir := fmt.Sprintf("%s/src/%s", gopath, base)
-		if err := os.MkdirAll(dir, os.ModeDir|0755); err != nil {
-			return nil, fmt.Errorf("Failed to make directory %s: %s", dir, err)
-		}
-	}
-
-	ldest := fmt.Sprintf("%s/src/%s", gopath, pname)
-	if err := os.Symlink(here, ldest); err != nil {
-		if os.IsExist(err) {
-			Info("Link to %s already exists. Skipping.\n", ldest)
-		} else {
-			return nil, fmt.Errorf("Failed to create symlink from %s to %s: %s", gopath, ldest, err)
-		}
-	}
-
-	return ldest, nil
-}
diff --git a/cmd/mkdir.go b/cmd/mkdir.go
deleted file mode 100644
index d478845..0000000
--- a/cmd/mkdir.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/Masterminds/cookoo"
-)
-
-// Mkdir creates the src directory within the GOPATH.
-func Mkdir(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-
-	target := p.Get("dir", "").(string)
-	if len(target) == 0 {
-		return nil, fmt.Errorf("Vendor path appears to be unset")
-	}
-
-	if err := os.MkdirAll(target, os.ModeDir|0755); err != nil {
-		return false, fmt.Errorf("Failed to make directory %s: %s", target, err)
-	}
-
-	return true, nil
-}
diff --git a/cmd/msg.go b/cmd/msg.go
deleted file mode 100644
index a6dcc14..0000000
--- a/cmd/msg.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// +build !windows
-
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-)
-
-// These contanstants map to color codes for shell scripts making them
-// human readable.
-const (
-	Blue   = "0;34"
-	Red    = "0;31"
-	Green  = "0;32"
-	Yellow = "0;33"
-	Cyan   = "0;36"
-	Pink   = "1;35"
-)
-
-var outputLock sync.Mutex
-
-// Color returns a string in a certain color. The first argument is a string
-// containing the color code or a constant from the table above mapped to a code.
-//
-// The following will print the string "Foo" in yellow:
-//     fmt.Print(Color(Yellow, "Foo"))
-func Color(code, msg string) string {
-	if NoColor {
-		return msg
-	}
-	return fmt.Sprintf("\033[%sm%s\033[m", code, msg)
-}
-
-// Info logs information
-func Info(msg string, args ...interface{}) {
-	if Quiet {
-		return
-	}
-	i := fmt.Sprint(Color(Green, "[INFO] "))
-	Msg(i+msg, args...)
-}
-
-// Debug logs debug information
-func Debug(msg string, args ...interface{}) {
-	if Quiet || !IsDebugging {
-		return
-	}
-	i := fmt.Sprint("[DEBUG] ")
-	Msg(i+msg, args...)
-}
-
-// Warn logs a warning
-func Warn(msg string, args ...interface{}) {
-	i := fmt.Sprint(Color(Yellow, "[WARN] "))
-	ErrMsg(i+msg, args...)
-}
-
-// Error logs and error.
-func Error(msg string, args ...interface{}) {
-	i := fmt.Sprint(Color(Red, "[ERROR] "))
-	ErrMsg(i+msg, args...)
-}
-
-// ErrMsg sends a message to Stderr
-func ErrMsg(msg string, args ...interface{}) {
-	outputLock.Lock()
-	defer outputLock.Unlock()
-
-	// If messages don't have a newline on the end we add one.
-	e := ""
-	if !strings.HasSuffix(msg, "\n") {
-		e = "\n"
-	}
-	if len(args) == 0 {
-		fmt.Fprint(os.Stderr, msg+e)
-	} else {
-		fmt.Fprintf(os.Stderr, msg+e, args...)
-	}
-}
-
-// Msg prints a message with optional arguments, that can be printed, of
-// varying types.
-func Msg(msg string, args ...interface{}) {
-	outputLock.Lock()
-	defer outputLock.Unlock()
-
-	// If messages don't have a newline on the end we add one.
-	e := ""
-	if !strings.HasSuffix(msg, "\n") {
-		e = "\n"
-	}
-	if len(args) == 0 {
-		fmt.Fprint(os.Stderr, msg+e)
-	} else {
-		fmt.Fprintf(os.Stderr, msg+e, args...)
-	}
-}
diff --git a/cmd/msg_windows.go b/cmd/msg_windows.go
deleted file mode 100644
index 6774ebd..0000000
--- a/cmd/msg_windows.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// +build windows
-
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"strings"
-)
-
-// Info logs information
-func Info(msg string, args ...interface{}) {
-	if Quiet {
-		return
-	}
-	fmt.Print("[INFO] ")
-	Msg(msg, args...)
-}
-
-// Debug logs debug information
-func Debug(msg string, args ...interface{}) {
-	if Quiet || !IsDebugging {
-		return
-	}
-	fmt.Print("[DEBUG] ")
-	Msg(msg, args...)
-}
-
-// Warn logs a warning
-func Warn(msg string, args ...interface{}) {
-	fmt.Fprint(os.Stderr, "[WARN] ")
-	ErrMsg(msg, args...)
-}
-
-// Error logs and error.
-func Error(msg string, args ...interface{}) {
-	fmt.Fprint(os.Stderr, "[ERROR] ")
-	ErrMsg(msg, args...)
-}
-
-// ErrMsg sends a message to Stderr
-func ErrMsg(msg string, args ...interface{}) {
-	if len(args) == 0 {
-		fmt.Fprint(os.Stderr, msg)
-		return
-	}
-	fmt.Fprintf(os.Stderr, msg, args...)
-}
-
-// Msg prints a message with optional arguments, that can be printed, of
-// varying types.
-func Msg(msg string, args ...interface{}) {
-	if len(args) == 0 {
-		fmt.Print(msg)
-		return
-	}
-	fmt.Printf(msg, args...)
-
-	// Get rid of the annoying fact that messages need \n at the end, but do
-	// it in a backward compatible way.
-	if !strings.HasSuffix(msg, "\n") {
-		fmt.Println("")
-	}
-}
diff --git a/cmd/novendor.go b/cmd/novendor.go
deleted file mode 100644
index b0adcd3..0000000
--- a/cmd/novendor.go
+++ /dev/null
@@ -1,134 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-)
-
-// NoVendor takes a path and returns all subpaths that are not vendor directories.
-//
-// It is not recursive.
-//
-// If the given path is a file, it returns that path unaltered.
-//
-// If the given path is a directory, it scans all of the immediate children,
-// and returns all of the go files and directories that are not vendor.
-func NoVendor(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	path := p.Get("path", ".").(string)
-	gonly := p.Get("onlyGo", true).(bool)
-
-	return noVend(path, gonly)
-}
-
-// Take a list of paths and print a single string with space-separated paths.
-func PathString(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	paths := p.Get("paths", []string{}).([]string)
-	s := strings.Join(paths, " ")
-	fmt.Println(s)
-	return nil, nil
-}
-
-// noVend takes a directory and returns a list of Go-like files or directories,
-// provided the directory is not a vendor directory.
-//
-// If onlyGo is true, this will filter out all directories that do not contain
-// ".go" files.
-func noVend(path string, onlyGo bool) ([]string, error) {
-
-	info, err := os.Stat(path)
-	if err != nil {
-		return []string{}, err
-	}
-
-	if !info.IsDir() {
-		return []string{path}, nil
-	}
-
-	res := []string{}
-	f, err := os.Open(path)
-	if err != nil {
-		return res, err
-	}
-
-	fis, err := f.Readdir(0)
-	if err != nil {
-		return res, err
-	}
-
-	cur := false
-
-	for _, fi := range fis {
-		if exclude(fi) {
-			continue
-		}
-
-		full := filepath.Join(path, fi.Name())
-		if fi.IsDir() && !isVend(fi) {
-			p := "./" + full + "/..."
-			res = append(res, p)
-		} else if !fi.IsDir() && isGoish(fi) {
-			//res = append(res, full)
-			cur = true
-		}
-	}
-
-	// Filter out directories that do not contain Go code
-	if onlyGo {
-		res = hasGoSource(res)
-	}
-
-	if cur {
-		res = append(res, ".")
-	}
-
-	return res, nil
-}
-
-func hasGoSource(dirs []string) []string {
-	buf := []string{}
-	for _, d := range dirs {
-		d := filepath.Dir(d)
-		found := false
-		walker := func(p string, fi os.FileInfo, err error) error {
-			// Dumb optimization
-			if found {
-				return nil
-			}
-
-			// If the file ends with .go, report a match.
-			if strings.ToLower(filepath.Ext(p)) == ".go" {
-				found = true
-			}
-
-			return nil
-		}
-		filepath.Walk(d, walker)
-
-		if found {
-			buf = append(buf, "./"+d+"/...")
-		}
-	}
-	return buf
-}
-
-func isVend(fi os.FileInfo) bool {
-	return fi.Name() == "vendor"
-}
-
-func exclude(fi os.FileInfo) bool {
-	if strings.HasPrefix(fi.Name(), "_") {
-		return true
-	}
-	if strings.HasPrefix(fi.Name(), ".") {
-		return true
-	}
-	return false
-}
-
-func isGoish(fi os.FileInfo) bool {
-	return filepath.Ext(fi.Name()) == ".go"
-}
diff --git a/cmd/print_name.go b/cmd/print_name.go
deleted file mode 100644
index 6a6d26d..0000000
--- a/cmd/print_name.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-)
-
-// PrintName prints the name of the project.
-//
-// This comes from Config.Name.
-func PrintName(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	conf := p.Get("conf", nil).(*cfg.Config)
-	fmt.Println(conf.Name)
-	return nil, nil
-}
diff --git a/cmd/rebuild.go b/cmd/rebuild.go
deleted file mode 100644
index 07a1449..0000000
--- a/cmd/rebuild.go
+++ /dev/null
@@ -1,99 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-)
-
-// Rebuild runs 'go build' in a directory.
-//
-// Params:
-// 	- conf: the *cfg.Config.
-//
-func Rebuild(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	conf := p.Get("conf", nil).(*cfg.Config)
-	vpath, err := VendorPath(c)
-	if err != nil {
-		return nil, err
-	}
-
-	Info("Building dependencies.\n")
-
-	if len(conf.Imports) == 0 {
-		Info("No dependencies found. Nothing built.\n")
-		return true, nil
-	}
-
-	for _, dep := range conf.Imports {
-		if err := buildDep(c, dep, vpath); err != nil {
-			Warn("Failed to build %s: %s\n", dep.Name, err)
-		}
-	}
-
-	return true, nil
-}
-
-func buildDep(c cookoo.Context, dep *cfg.Dependency, vpath string) error {
-	if len(dep.Subpackages) == 0 {
-		buildPath(c, dep.Name)
-	}
-
-	for _, pkg := range dep.Subpackages {
-		if pkg == "**" || pkg == "..." {
-			//Info("Building all packages in %s\n", dep.Name)
-			buildPath(c, path.Join(dep.Name, "..."))
-		} else {
-			paths, err := resolvePackages(vpath, dep.Name, pkg)
-			if err != nil {
-				Warn("Error resolving packages: %s", err)
-			}
-			buildPaths(c, paths)
-		}
-	}
-
-	return nil
-}
-
-func resolvePackages(vpath, pkg, subpkg string) ([]string, error) {
-	sdir, _ := os.Getwd()
-	if err := os.Chdir(filepath.Join(vpath, filepath.FromSlash(pkg), filepath.FromSlash(subpkg))); err != nil {
-		return []string{}, err
-	}
-	defer os.Chdir(sdir)
-	p, err := filepath.Glob(filepath.Join(vpath, filepath.FromSlash(pkg), filepath.FromSlash(subpkg)))
-	if err != nil {
-		return []string{}, err
-	}
-	for k, v := range p {
-		nv := strings.TrimPrefix(v, vpath)
-		p[k] = strings.TrimPrefix(nv, string(filepath.Separator))
-	}
-	return p, nil
-}
-
-func buildPaths(c cookoo.Context, paths []string) error {
-	for _, path := range paths {
-		if err := buildPath(c, path); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func buildPath(c cookoo.Context, path string) error {
-	Info("Running go build %s\n", path)
-	// . in a filepath.Join is removed so it needs to be prepended separately.
-	p := "." + string(filepath.Separator) + filepath.Join("vendor", filepath.FromSlash(path))
-	out, err := exec.Command("go", "install", p).CombinedOutput()
-	if err != nil {
-		Warn("Failed to run 'go install' for %s: %s", path, string(out))
-	}
-	return err
-}
diff --git a/cmd/tree.go b/cmd/tree.go
deleted file mode 100644
index 252405e..0000000
--- a/cmd/tree.go
+++ /dev/null
@@ -1,331 +0,0 @@
-package cmd
-
-import (
-	"container/list"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/dependency"
-	"github.com/Masterminds/glide/msg"
-	"github.com/Masterminds/glide/util"
-)
-
-// Tree prints a tree representing dependencies.
-func Tree(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	buildContext, err := util.GetBuildContext()
-	if err != nil {
-		return nil, err
-	}
-	showcore := p.Get("showcore", false).(bool)
-	basedir := p.Get("dir", ".").(string)
-	myName := guessPackageName(buildContext, basedir)
-
-	if basedir == "." {
-		var err error
-		basedir, err = os.Getwd()
-		if err != nil {
-			Error("Could not get working directory")
-			return nil, err
-		}
-	}
-
-	fmt.Println(myName)
-	l := list.New()
-	l.PushBack(myName)
-	displayTree(buildContext, basedir, myName, 1, showcore, l)
-	return nil, nil
-}
-
-// ListDeps lists all of the dependencies of the current project.
-//
-// Params:
-//  - dir (string): basedir
-//  - deep (bool): whether to do a deep scan or a shallow scan
-//
-// Returns:
-//
-func ListDeps(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	basedir := p.Get("dir", ".").(string)
-	deep := p.Get("deep", true).(bool)
-
-	basedir, err := filepath.Abs(basedir)
-	if err != nil {
-		return nil, err
-	}
-
-	r, err := dependency.NewResolver(basedir)
-	if err != nil {
-		return nil, err
-	}
-	h := &dependency.DefaultMissingPackageHandler{Missing: []string{}, Gopath: []string{}}
-	r.Handler = h
-
-	sortable, err := r.ResolveLocal(deep)
-	if err != nil {
-		return nil, err
-	}
-
-	sort.Strings(sortable)
-
-	fmt.Println("INSTALLED packages:")
-	for _, k := range sortable {
-		v, err := filepath.Rel(basedir, k)
-		if err != nil {
-			msg.Warn("Failed to Rel path: %s", err)
-			v = k
-		}
-		fmt.Printf("\t%s\n", v)
-	}
-
-	if len(h.Missing) > 0 {
-		fmt.Println("\nMISSING packages:")
-		for _, pkg := range h.Missing {
-			fmt.Printf("\t%s\n", pkg)
-		}
-	}
-	if len(h.Gopath) > 0 {
-		fmt.Println("\nGOPATH packages:")
-		for _, pkg := range h.Gopath {
-			fmt.Printf("\t%s\n", pkg)
-		}
-	}
-
-	return nil, nil
-}
-
-func listDeps(b *util.BuildCtxt, info map[string]*pinfo, name, path string) {
-	found := findPkg(b, name, path)
-	switch found.PType {
-	case ptypeUnknown:
-		info[name] = found
-		break
-	case ptypeGoroot, ptypeCgo:
-		break
-	default:
-		info[name] = found
-		for _, i := range walkDeps(b, found.Path, found.Name) {
-			// Only walk the deps that are not already found to avoid
-			// infinite recursion.
-			if _, f := info[found.Name]; f == false {
-				listDeps(b, info, i, found.Path)
-			}
-		}
-	}
-}
-
-func displayTree(b *util.BuildCtxt, basedir, myName string, level int, core bool, l *list.List) {
-	deps := walkDeps(b, basedir, myName)
-	for _, name := range deps {
-		found := findPkg(b, name, basedir)
-		if found.PType == ptypeUnknown {
-			msg := "glide get " + found.Name
-			fmt.Printf("\t%s\t(%s)\n", found.Name, msg)
-			continue
-		}
-		if !core && found.PType == ptypeGoroot || found.PType == ptypeCgo {
-			continue
-		}
-		fmt.Print(strings.Repeat("\t", level))
-
-		f := findInList(found.Name, l)
-		if f == true {
-			fmt.Printf("(Recursion) %s   (%s)\n", found.Name, found.Path)
-		} else {
-			// Every branch in the tree is a copy to handle all the branches
-			cl := copyList(l)
-			cl.PushBack(found.Name)
-			fmt.Printf("%s   (%s)\n", found.Name, found.Path)
-			displayTree(b, found.Path, found.Name, level+1, core, cl)
-		}
-	}
-}
-
-type ptype int8
-
-const (
-	ptypeUnknown ptype = iota
-	ptypeLocal
-	ptypeVendor
-	ptypeGopath
-	ptypeGoroot
-	ptypeCgo
-)
-
-func ptypeString(t ptype) string {
-	switch t {
-	case ptypeLocal:
-		return "local"
-	case ptypeVendor:
-		return "vendored"
-	case ptypeGopath:
-		return "gopath"
-	case ptypeGoroot:
-		return "core"
-	case ptypeCgo:
-		return "cgo"
-	default:
-		return "missing"
-	}
-}
-
-type pinfo struct {
-	Name, Path string
-	PType      ptype
-	Vendored   bool
-}
-
-func findPkg(b *util.BuildCtxt, name, cwd string) *pinfo {
-	var fi os.FileInfo
-	var err error
-	var p string
-
-	info := &pinfo{
-		Name: name,
-	}
-
-	// Recurse backward to scan other vendor/ directories
-	// If the cwd isn't an absolute path walking upwards looking for vendor/
-	// folders can get into an infinate loop.
-	abs, err := filepath.Abs(cwd)
-	if err != nil {
-		abs = cwd
-	}
-	if abs != "." {
-
-		// Previously there was a check on the loop that wd := "/". The path
-		// "/" is a POSIX path so this fails on Windows. Now the check is to
-		// make sure the same wd isn't seen twice. When the same wd happens
-		// more than once it's the beginning of looping on the same location
-		// which is the top level.
-		pwd := ""
-		for wd := abs; wd != pwd; wd = filepath.Dir(wd) {
-			pwd = wd
-
-			// Don't look for packages outside the GOPATH
-			// Note, the GOPATH may or may not end with the path separator.
-			// The output of filepath.Dir does not the the path separator on the
-			// end so we need to test both.
-			if wd == b.GOPATH || wd+string(os.PathSeparator) == b.GOPATH {
-				break
-			}
-			p = filepath.Join(wd, "vendor", filepath.FromSlash(name))
-			if fi, err = os.Stat(p); err == nil && (fi.IsDir() || isLink(fi)) {
-				info.Path = p
-				info.PType = ptypeVendor
-				info.Vendored = true
-				return info
-			}
-		}
-	}
-	// Check $GOPATH
-	for _, r := range filepath.SplitList(b.GOPATH) {
-		p = filepath.Join(r, "src", filepath.FromSlash(name))
-		if fi, err = os.Stat(p); err == nil && (fi.IsDir() || isLink(fi)) {
-			info.Path = p
-			info.PType = ptypeGopath
-			return info
-		}
-	}
-
-	// Check $GOROOT
-	for _, r := range filepath.SplitList(b.GOROOT) {
-		p = filepath.Join(r, "src", filepath.FromSlash(name))
-		if fi, err = os.Stat(p); err == nil && (fi.IsDir() || isLink(fi)) {
-			info.Path = p
-			info.PType = ptypeGoroot
-			return info
-		}
-	}
-
-	// Finally, if this is "C", we're dealing with cgo
-	if name == "C" {
-		info.PType = ptypeCgo
-	}
-
-	return info
-}
-
-func isLink(fi os.FileInfo) bool {
-	return fi.Mode()&os.ModeSymlink == os.ModeSymlink
-}
-
-func walkDeps(b *util.BuildCtxt, base, myName string) []string {
-	externalDeps := []string{}
-	filepath.Walk(base, func(path string, fi os.FileInfo, err error) error {
-		if excludeSubtree(path, fi) {
-			if fi.IsDir() {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-
-		pkg, err := b.ImportDir(path, 0)
-		if err != nil {
-			if !strings.HasPrefix(err.Error(), "no buildable Go source") {
-				Warn("Error: %s (%s)", err, path)
-				// Not sure if we should return here.
-				//return err
-			}
-		}
-
-		if pkg.Goroot {
-			return nil
-		}
-
-		for _, imp := range pkg.Imports {
-			//if strings.HasPrefix(imp, myName) {
-			////Info("Skipping %s because it is a subpackage of %s", imp, myName)
-			//continue
-			//}
-			if imp == myName {
-				continue
-			}
-			externalDeps = append(externalDeps, imp)
-		}
-
-		return nil
-	})
-	return externalDeps
-}
-
-func excludeSubtree(path string, fi os.FileInfo) bool {
-	top := filepath.Base(path)
-
-	if !fi.IsDir() && !isLink(fi) {
-		return true
-	}
-
-	// Provisionally, we'll skip vendor. We definitely
-	// should skip testdata.
-	if top == "vendor" || top == "testdata" {
-		return true
-	}
-
-	// Skip anything that starts with _
-	if strings.HasPrefix(top, "_") || (strings.HasPrefix(top, ".") && top != ".") {
-		return true
-	}
-	return false
-}
-
-func copyList(l *list.List) *list.List {
-	n := list.New()
-	for e := l.Front(); e != nil; e = e.Next() {
-		n.PushBack(e.Value.(string))
-	}
-	return n
-}
-
-func findInList(n string, l *list.List) bool {
-	for e := l.Front(); e != nil; e = e.Next() {
-		if e.Value.(string) == n {
-			return true
-		}
-	}
-
-	return false
-}
diff --git a/cmd/tree_test.go b/cmd/tree_test.go
deleted file mode 100644
index afa6667..0000000
--- a/cmd/tree_test.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package cmd
-
-import (
-	"container/list"
-	"testing"
-)
-
-func TestFindInTree(t *testing.T) {
-	l := list.New()
-	l.PushBack("github.com/Masterminds/glide")
-	l.PushBack("github.com/Masterminds/vcs")
-	l.PushBack("github.com/Masterminds/semver")
-
-	f := findInList("foo", l)
-	if f != false {
-		t.Error("findInList found true instead of false")
-	}
-
-	f = findInList("github.com/Masterminds/vcs", l)
-	if f != true {
-		t.Error("findInList found false instead of true")
-	}
-}
diff --git a/cmd/util.go b/cmd/util.go
deleted file mode 100644
index 6744173..0000000
--- a/cmd/util.go
+++ /dev/null
@@ -1,215 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-)
-
-// Quiet, when set to true, can suppress Info and Debug messages.
-var Quiet = false
-var IsDebugging = false
-var NoColor = false
-
-// BeQuiet supresses Info and Debug messages.
-func BeQuiet(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	Quiet = p.Get("quiet", false).(bool)
-	IsDebugging = p.Get("debug", false).(bool)
-	return Quiet, nil
-}
-
-// CheckColor turns off the colored output (and uses plain text output) for
-// logging depending on the value of the "no-color" flag.
-func CheckColor(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	NoColor = p.Get("no-color", false).(bool)
-	return NoColor, nil
-}
-
-// ReadyToGlide fails if the environment is not sufficient for using glide.
-//
-// Most importantly, it fails if glide.yaml is not present in the current
-// working directory.
-func ReadyToGlide(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	fname := p.Get("filename", "glide.yaml").(string)
-	if _, err := os.Stat(fname); err != nil {
-		cwd, _ := os.Getwd()
-		return false, fmt.Errorf("%s is missing from %s", fname, cwd)
-	}
-	return true, nil
-}
-
-// VersionGuard ensures that the Go version is correct.
-func VersionGuard(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	// 6l was removed in 1.5, when vendoring was introduced.
-	cmd := exec.Command("go", "tool", "6l")
-	var out string
-	if _, err := cmd.CombinedOutput(); err == nil {
-		Warn("You must install the Go 1.5 or greater toolchain to work with Glide.\n")
-	}
-	if os.Getenv("GO15VENDOREXPERIMENT") != "1" {
-		Warn("To use Glide, you must set GO15VENDOREXPERIMENT=1\n")
-	}
-
-	// Verify the setup isn't for the old version of glide. That is, this is
-	// no longer assuming the _vendor directory as the GOPATH. Inform of
-	// the change.
-	if _, err := os.Stat("_vendor/"); err == nil {
-		Warn(`Your setup appears to be for the previous version of Glide.
-Previously, vendor packages were stored in _vendor/src/ and
-_vendor was set as your GOPATH. As of Go 1.5 the go tools
-recognize the vendor directory as a location for these
-files. Glide has embraced this. Please remove the _vendor
-directory or move the _vendor/src/ directory to vendor/.` + "\n")
-	}
-
-	return out, nil
-}
-
-// CowardMode checks that the environment is setup before continuing on. If not
-// setup and error is returned.
-func CowardMode(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	gopath := Gopath()
-	if gopath == "" {
-		return false, fmt.Errorf("No GOPATH is set.\n")
-	}
-
-	_, err := os.Stat(filepath.Join(gopath, "src"))
-	if err != nil {
-		Error("Could not find %s/src. The GOPATH does not appear to be properly setup.\n", gopath)
-		Info("As of Glide 0.5/Go 1.5, this is required.\n")
-		return false, err
-	}
-
-	return true, nil
-}
-
-// Check if a directory is empty or not.
-func isDirectoryEmpty(dir string) (bool, error) {
-	f, err := os.Open(dir)
-	if err != nil {
-		return false, err
-	}
-	defer f.Close()
-
-	_, err = f.Readdir(1)
-
-	if err == io.EOF {
-		return true, nil
-	}
-
-	return false, err
-}
-
-// Gopath gets GOPATH from environment and return the most relevant path.
-//
-// A GOPATH can contain a colon-separated list of paths. This retrieves the
-// GOPATH and returns only the FIRST ("most relevant") path.
-//
-// This should be used carefully. If, for example, you are looking for a package,
-// you may be better off using Gopaths.
-func Gopath() string {
-	gopaths := Gopaths()
-	if len(gopaths) == 0 {
-		return ""
-	}
-	return gopaths[0]
-}
-
-// Gopaths retrieves the Gopath as a list when there is more than one path
-// listed in the Gopath.
-func Gopaths() []string {
-	p := os.Getenv("GOPATH")
-	p = strings.Trim(p, string(filepath.ListSeparator))
-	return filepath.SplitList(p)
-}
-
-func fileExist(name string) (bool, error) {
-	_, err := os.Stat(name)
-	if err == nil {
-		return true, nil
-	}
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	return true, err
-}
-
-// We copy the directory here rather than jumping out to a shell so we can
-// support multiple operating systems.
-func copyDir(source string, dest string) error {
-
-	// get properties of source dir
-	si, err := os.Stat(source)
-	if err != nil {
-		return err
-	}
-
-	err = os.MkdirAll(dest, si.Mode())
-	if err != nil {
-		return err
-	}
-
-	d, _ := os.Open(source)
-
-	objects, err := d.Readdir(-1)
-
-	for _, obj := range objects {
-
-		sp := filepath.Join(source, obj.Name())
-
-		dp := filepath.Join(dest, obj.Name())
-
-		if obj.IsDir() {
-			err = copyDir(sp, dp)
-			if err != nil {
-				return err
-			}
-		} else {
-			// perform copy
-			err = copyFile(sp, dp)
-			if err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func copyFile(source string, dest string) error {
-	ln, err := os.Readlink(source)
-	if err == nil {
-		return os.Symlink(ln, dest)
-	}
-	s, err := os.Open(source)
-	if err != nil {
-		return err
-	}
-
-	defer s.Close()
-
-	d, err := os.Create(dest)
-	if err != nil {
-		return err
-	}
-
-	defer d.Close()
-
-	_, err = io.Copy(d, s)
-	if err != nil {
-		return err
-	}
-
-	si, err := os.Stat(source)
-	if err != nil {
-		return err
-	}
-	err = os.Chmod(dest, si.Mode())
-
-	return err
-}
diff --git a/cmd/util_test.go b/cmd/util_test.go
deleted file mode 100644
index 89a041a..0000000
--- a/cmd/util_test.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package cmd
-
-import (
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-func TestisDirectoryEmpty(t *testing.T) {
-	tempDir, err := ioutil.TempDir("", "empty-dir-test")
-	if err != nil {
-		t.Error(err)
-	}
-	defer func() {
-		err = os.RemoveAll(tempDir)
-		if err != nil {
-			t.Error(err)
-		}
-	}()
-
-	empty, err := isDirectoryEmpty(tempDir)
-	if err != nil {
-		t.Error(err)
-	}
-	if empty == false {
-		t.Error("isDirectoryEmpty reporting false on empty directory")
-	}
-
-	data := "foo bar baz"
-	err = ioutil.WriteFile(tempDir+"/foo", []byte(data), 0644)
-	if err != nil {
-		t.Error(err)
-	}
-
-	empty, err = isDirectoryEmpty(tempDir)
-	if err != nil {
-		t.Error(err)
-	}
-	if empty == true {
-		t.Error("isDirectoryEmpty reporting true on non-empty directory")
-	}
-}
diff --git a/cmd/vendor_path.go b/cmd/vendor_path.go
deleted file mode 100644
index 0b3dc75..0000000
--- a/cmd/vendor_path.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/Masterminds/cookoo"
-)
-
-// Return the path to the vendor directory.
-func VendorPath(c cookoo.Context) (string, error) {
-	vendor := c.Get("VendorDir", "vendor").(string)
-	filename := c.Get("yaml", "glide.yaml").(string)
-	cwd, err := os.Getwd()
-	if err != nil {
-		return "", err
-	}
-
-	// Find the directory that contains glide.yaml
-	yamldir, err := glideWD(cwd, filename)
-	if err != nil {
-		return cwd, err
-	}
-
-	gopath := filepath.Join(yamldir, vendor)
-
-	return gopath, nil
-}
-
-func glideWD(dir, filename string) (string, error) {
-	fullpath := filepath.Join(dir, filename)
-
-	if _, err := os.Stat(fullpath); err == nil {
-		return dir, nil
-	}
-
-	base := filepath.Dir(dir)
-	if base == dir {
-		return "", fmt.Errorf("Cannot resolve parent of %s", base)
-	}
-
-	return glideWD(base, filename)
-}
diff --git a/cmd/vendor_path_test.go b/cmd/vendor_path_test.go
deleted file mode 100644
index 258b8b5..0000000
--- a/cmd/vendor_path_test.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestGlideWD(t *testing.T) {
-	cwd, _ := os.Getwd()
-	filename := "glide.yaml"
-	found, err := glideWD(cwd, filename)
-	if err != nil {
-		t.Errorf("Failed to get Glide directory: %s", err)
-	}
-
-	if found != filepath.Dir(cwd) {
-		t.Errorf("Expected %s to match %s", found, filepath.Base(cwd))
-	}
-
-	// This should fail
-	cwd = "/No/Such/Dir"
-	found, err = glideWD(cwd, filename)
-	if err == nil {
-		t.Errorf("Expected to get an error on a non-existent directory, not %s", found)
-	}
-
-}
diff --git a/cmd/vendored.go b/cmd/vendored.go
deleted file mode 100644
index 6dfbda0..0000000
--- a/cmd/vendored.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-)
-
-// If we are updating the vendored dependencies. That is those stored in the
-// local project VCS.
-var updatingVendored = false
-
-// VendoredSetup is a command that does the setup for vendored directories.
-// If enabled (via update) it marks vendored directories that are being updated
-// and removed the old code. This should be a prefix to UpdateImports and
-// VendoredCleanUp should be a suffix to UpdateImports.
-func VendoredSetup(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	update := p.Get("update", false).(bool)
-	conf := p.Get("conf", nil).(*cfg.Config)
-
-	updatingVendored = update
-
-	return conf, nil
-}
-
-// VendoredCleanUp is a command that cleans up vendored codebases after an update.
-// If enabled (via update) it removes the VCS info from updated vendored
-// packages. This should be a suffix to UpdateImports and  VendoredSetup should
-// be a prefix to UpdateImports.
-func VendoredCleanUp(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	update := p.Get("update", true).(bool)
-	if update != true {
-		return false, nil
-	}
-	conf := p.Get("conf", nil).(*cfg.Config)
-
-	vend, err := VendorPath(c)
-	if err != nil {
-		return false, err
-	}
-
-	for _, dep := range conf.Imports {
-		if dep.UpdateAsVendored == true {
-			Info("Cleaning up vendored package %s\n", dep.Name)
-
-			// Remove the VCS directory
-			cwd := filepath.Join(vend, filepath.FromSlash(dep.Name))
-			repo, err := dep.GetRepo(cwd)
-			if err != nil {
-				Error("Error cleaning up %s:%s", dep.Name, err)
-				continue
-			}
-			t := repo.Vcs()
-			err = os.RemoveAll(cwd + string(os.PathSeparator) + "." + string(t))
-			if err != nil {
-				Error("Error cleaning up VCS dir for %s:%s", dep.Name, err)
-			}
-		}
-
-	}
-
-	return true, nil
-}
diff --git a/cmd/yaml.go b/cmd/yaml.go
deleted file mode 100644
index f05a1e9..0000000
--- a/cmd/yaml.go
+++ /dev/null
@@ -1,196 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-	"github.com/Masterminds/glide/util"
-)
-
-// ParseYaml parses the glide.yaml format and returns a Configuration object.
-//
-// Params:
-//	- filename (string): YAML filename as a string
-//
-// Returns:
-//	- *cfg.Config: The configuration.
-func ParseYaml(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	fname := p.Get("filename", "glide.yaml").(string)
-	//conf := new(Config)
-	yml, err := ioutil.ReadFile(fname)
-	if err != nil {
-		return nil, err
-	}
-	conf, err := cfg.ConfigFromYaml(yml)
-	if err != nil {
-		return nil, err
-	}
-
-	return conf, nil
-}
-
-// ParseYamlString parses a YAML string. This is similar but different to
-// ParseYaml that parses an external file.
-//
-// Params:
-//	- yaml (string): YAML as a string.
-//
-// Returns:
-//	- *cfg.Config: The configuration.
-func ParseYamlString(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	yamlString := p.Get("yaml", "").(string)
-
-	conf, err := cfg.ConfigFromYaml([]byte(yamlString))
-	if err != nil {
-		return nil, err
-	}
-
-	return conf, nil
-}
-
-// GuardYaml protects the glide yaml file from being overwritten.
-func GuardYaml(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	fname := p.Get("filename", "glide.yaml").(string)
-	if _, err := os.Stat(fname); err == nil {
-		cwd, _ := os.Getwd()
-		return false, fmt.Errorf("Cowardly refusing to overwrite %s in %s", fname, cwd)
-	}
-
-	return true, nil
-}
-
-// WriteYaml writes the config as YAML.
-//
-// Params:
-//	- conf: A *cfg.Config to render.
-// 	- out (io.Writer): An output stream to write to. Default is os.Stdout.
-// 	- filename (string): If set, the file will be opened and the content will be written to it.
-func WriteYaml(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	conf := p.Get("conf", nil).(*cfg.Config)
-	toStdout := p.Get("toStdout", true).(bool)
-
-	data, err := conf.Marshal()
-	if err != nil {
-		return nil, err
-	}
-
-	var out io.Writer
-	if nn, ok := p.Has("filename"); ok && len(nn.(string)) > 0 {
-		file, err := os.Create(nn.(string))
-		if err != nil {
-		}
-		defer file.Close()
-		out = io.Writer(file)
-		//fmt.Fprint(out, yml)
-		out.Write(data)
-	} else if toStdout {
-		out = p.Get("out", os.Stdout).(io.Writer)
-		//fmt.Fprint(out, yml)
-		out.Write(data)
-	}
-
-	// Otherwise we supress output.
-	return true, nil
-}
-
-// WriteLock writes the lock as YAML.
-//
-// Params:
-//	- lockfile: A *cfg.Lockfile to render.
-// 	- out (io.Writer): An output stream to write to. Default is os.Stdout.
-func WriteLock(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	skip := p.Get("skip", false).(bool)
-	if skip {
-		return false, nil
-	}
-
-	lockfile := p.Get("lockfile", nil).(*cfg.Lockfile)
-
-	Info("Writing glide.lock file")
-
-	data, err := lockfile.Marshal()
-	if err != nil {
-		return nil, err
-	}
-
-	var out io.Writer
-	file, err := os.Create("glide.lock")
-	if err != nil {
-		return false, err
-	}
-	defer file.Close()
-	out = io.Writer(file)
-	out.Write(data)
-
-	return true, nil
-}
-
-// AddDependencies adds a list of *Dependency objects to the given *cfg.Config.
-//
-// This is used to merge in packages from other sources or config files.
-func AddDependencies(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	deps := p.Get("dependencies", []*cfg.Dependency{}).([]*cfg.Dependency)
-	config := p.Get("conf", nil).(*cfg.Config)
-
-	// Make a set of existing package names for quick comparison.
-	pkgSet := make(map[string]bool, len(config.Imports))
-	for _, p := range config.Imports {
-		pkgSet[p.Name] = true
-	}
-
-	// If a dep is not already present, add it.
-	for _, dep := range deps {
-		if _, ok := pkgSet[dep.Name]; ok {
-			Warn("Package %s is already in glide.yaml. Skipping.\n", dep.Name)
-			continue
-		}
-		config.Imports = append(config.Imports, dep)
-	}
-
-	return true, nil
-}
-
-// NormalizeName takes a package name and normalizes it to the top level package.
-//
-// For example, golang.org/x/crypto/ssh becomes golang.org/x/crypto. 'ssh' is
-// returned as extra data.
-func NormalizeName(name string) (string, string) {
-
-	// Fastpath check if a name in the GOROOT. There is an issue when a pkg
-	// is in the GOROOT and GetRootFromPackage tries to look it up because it
-	// expects remote names.
-	b, err := util.GetBuildContext()
-	if err == nil {
-		p := filepath.Join(b.GOROOT, "src", filepath.FromSlash(name))
-		if _, err := os.Stat(p); err == nil {
-			return name, ""
-		}
-	}
-
-	root := util.GetRootFromPackage(name)
-	extra := strings.TrimPrefix(name, root)
-	if len(extra) > 0 && extra != "/" {
-		extra = strings.TrimPrefix(extra, "/")
-	} else {
-		// If extra is / (which is what it would be here) we want to return ""
-		extra = ""
-	}
-
-	return root, extra
-
-	// parts := strings.SplitN(name, "/", 4)
-	// extra := ""
-	// if len(parts) < 3 {
-	// 	return name, extra
-	// }
-	// if len(parts) == 4 {
-	// 	extra = parts[3]
-	// }
-	// return strings.Join(parts[0:3], "/"), extra
-}
diff --git a/cmd/yaml_test.go b/cmd/yaml_test.go
deleted file mode 100644
index a1e3e6b..0000000
--- a/cmd/yaml_test.go
+++ /dev/null
@@ -1,124 +0,0 @@
-package cmd
-
-import (
-	"testing"
-
-	"github.com/Masterminds/cookoo"
-	"github.com/Masterminds/glide/cfg"
-)
-
-var yamlFile = `
-package: fake/testing
-import:
-  - package: github.com/kylelemons/go-gypsy
-    subpackages:
-      - yaml
-  # Intentionally left spaces at end of next line.
-  - package: github.com/Masterminds/convert
-    repo: git@github.com:Masterminds/convert.git
-    ref: a9949121a2e2192ca92fa6dddfeaaa4a4412d955
-    subpackages:
-      - color
-      - nautical
-      - radial
-    os:
-      - linux
-    arch:
-      - i386
-      - arm
-  - package: github.com/Masterminds/structable
-
-devimport:
-  - package: github.com/kylelemons/go-gypsy
-`
-
-func TestFromYaml(t *testing.T) {
-	reg, router, cxt := cookoo.Cookoo()
-
-	reg.Route("t", "Testing").
-		Does(ParseYamlString, "cfg").Using("yaml").WithDefault(yamlFile)
-
-	if err := router.HandleRequest("t", cxt, false); err != nil {
-		t.Errorf("Failed to parse YAML: %s", err)
-	}
-
-	conf := cxt.Get("cfg", nil).(*cfg.Config)
-
-	if conf.Name != "fake/testing" {
-		t.Errorf("Expected name to be 'fake/teting', not '%s'", conf.Name)
-	}
-
-	if len(conf.Imports) != 3 {
-		t.Errorf("Expected 3 imports, got %d", len(conf.Imports))
-	}
-
-	if conf.Imports.Get("github.com/Masterminds/convert") == nil {
-		t.Error("Expected Imports.Get to return Dependency")
-	}
-
-	if conf.Imports.Get("github.com/doesnot/exist") != nil {
-		t.Error("Execpted Imports.Get to return nil")
-	}
-
-	var imp *cfg.Dependency
-	for _, d := range conf.Imports {
-		if d.Name == "github.com/Masterminds/convert" {
-			imp = d
-		}
-	}
-
-	if imp == nil {
-		t.Errorf("Expected the convert package, got nothing")
-	}
-
-	if len(imp.Subpackages) != 3 {
-		t.Errorf("Expected 3 subpackages. got %d", len(imp.Subpackages))
-	}
-
-	if imp.Subpackages[0] != "color" {
-		t.Errorf("Expected first subpackage to be 'color', got '%s'", imp.Subpackages[0])
-	}
-
-	if len(imp.Os) != 1 {
-		t.Errorf("Expected Os: SOMETHING")
-	} else if imp.Os[0] != "linux" {
-		t.Errorf("Expected Os: linux")
-	}
-
-	if len(imp.Arch) != 2 {
-		t.Error("Expected two Archs.")
-	} else if imp.Arch[0] != "i386" {
-		t.Errorf("Expected arch 1 to be i386, got %s.", imp.Arch[0])
-	} else if imp.Arch[1] != "arm" {
-		t.Error("Expected arch 2 to be arm.")
-	}
-
-	if imp.Repository != "git@github.com:Masterminds/convert.git" {
-		t.Errorf("Got wrong repo %s on %s", imp.Repository, imp.Name)
-	}
-	if imp.Reference != "a9949121a2e2192ca92fa6dddfeaaa4a4412d955" {
-		t.Errorf("Got wrong reference.")
-	}
-
-	if len(conf.DevImports) != 1 {
-		t.Errorf("Expected one dev import.")
-	}
-
-}
-
-func TestNormalizeName(t *testing.T) {
-	packages := map[string]string{
-		"github.com/Masterminds/cookoo/web/io/foo": "github.com/Masterminds/cookoo",
-		"golang.org/x/crypto/ssh":                  "golang.org/x/crypto",
-		//"technosophos.me/x/totally/fake/package":   "technosophos.me/x/totally",
-		"incomplete/example": "incomplete/example",
-		"net":                "net",
-	}
-	for start, expected := range packages {
-		if finish, extra := NormalizeName(start); expected != finish {
-			t.Errorf("Expected '%s', got '%s'", expected, finish)
-		} else if start != finish && start != finish+"/"+extra {
-			t.Errorf("Expected %s to end with %s", finish, extra)
-		}
-	}
-}
diff --git a/cmd/delete.go b/dependency/delete.go
similarity index 75%
rename from cmd/delete.go
rename to dependency/delete.go
index 202377a..39a6367 100644
--- a/cmd/delete.go
+++ b/dependency/delete.go
@@ -1,4 +1,4 @@
-package cmd
+package dependency
 
 import (
 	"errors"
@@ -6,38 +6,32 @@
 	"path/filepath"
 	"strings"
 
-	"github.com/Masterminds/cookoo"
 	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
 )
 
-// DeleteUnusedPackages removes packages from vendor/ that are no longer used.
-func DeleteUnusedPackages(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	// Conditional opt-in to removed unused dependencies.
-	optIn := p.Get("optIn", false).(bool)
-	if optIn != true {
-		return nil, nil
-	}
-
-	vpath, err := VendorPath(c)
+// DeleteUnused removes packages from vendor/ that are no longer used.
+//
+// TODO: This should work off of a Lock file, not glide.yaml.
+func DeleteUnused(conf *cfg.Config) error {
+	vpath, err := gpath.Vendor()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	if vpath == "" {
-		return false, errors.New("Vendor not set")
+		return errors.New("Vendor not set")
 	}
 
 	// Build directory tree of what to keep.
-	cfg := p.Get("conf", nil).(*cfg.Config)
 	var pkgList []string
-	for _, dep := range cfg.Imports {
+	for _, dep := range conf.Imports {
 		pkgList = append(pkgList, dep.Name)
 	}
 
-	// Callback function for filepath.Walk to delete packages not in yaml file.
 	var searchPath string
-
 	var markForDelete []string
-
+	// Callback function for filepath.Walk to delete packages not in yaml file.
 	fn := func(path string, info os.FileInfo, err error) error {
 		// Bubble up the error
 		if err != nil {
@@ -49,7 +43,6 @@
 		}
 
 		localPath := strings.TrimPrefix(path, searchPath)
-
 		keep := false
 
 		// First check if the path has a prefix that's a specific package. If
@@ -93,18 +86,18 @@
 	searchPath = vpath + string(os.PathSeparator)
 	err = filepath.Walk(searchPath, fn)
 	if err != nil {
-		return false, err
+		return err
 	}
 
 	// Perform the actual delete.
 	for _, path := range markForDelete {
 		localPath := strings.TrimPrefix(path, searchPath)
-		Info("Removing unused package: %s\n", localPath)
+		msg.Info("Removing unused package: %s\n", localPath)
 		rerr := os.RemoveAll(path)
 		if rerr != nil {
-			return false, rerr
+			return rerr
 		}
 	}
 
-	return nil, nil
+	return nil
 }
diff --git a/dependency/resolver.go b/dependency/resolver.go
index fcd4ddd..e08f738 100644
--- a/dependency/resolver.go
+++ b/dependency/resolver.go
@@ -69,6 +69,40 @@
 	return false, nil
 }
 
+// VersionHandler sets the version for a package when found while scanning.
+//
+// When a package if found it needs to be on the correct version before
+// scanning its contents to be sure to pick up the right elements for that
+// version.
+type VersionHandler interface {
+
+	// Process provides an opportunity to process the codebase for version setting.
+	Process(pkg string) error
+
+	// SetVersion sets the version for a package. An error is returned if there
+	// was a problem setting the version.
+	SetVersion(pkg string) error
+}
+
+// DefaultVersionHandler is the default handler for setting the version.
+//
+// The default handler leaves the current version and skips setting a version.
+// For a handler that alters the version see the handler included in the repo
+// package as part of the installer.
+type DefaultVersionHandler struct{}
+
+// Process a package to aide in version setting.
+func (d *DefaultVersionHandler) Process(pkg string) error {
+	return nil
+}
+
+// SetVersion here sends a message when a package is found noting that it
+// did not set the version.
+func (d *DefaultVersionHandler) SetVersion(pkg string) error {
+	msg.Warn("Version not set for package %s", pkg)
+	return nil
+}
+
 // Resolver resolves a dependency tree.
 //
 // It operates in two modes:
@@ -79,11 +113,13 @@
 // Local resolution is for guessing initial dependencies. Vendor resolution is
 // for determining vendored dependencies.
 type Resolver struct {
-	Handler      MissingPackageHandler
-	basedir      string
-	VendorDir    string
-	BuildContext *util.BuildCtxt
-	seen         map[string]bool
+	Handler        MissingPackageHandler
+	VersionHandler VersionHandler
+	basedir        string
+	VendorDir      string
+	BuildContext   *util.BuildCtxt
+	seen           map[string]bool
+	Config         *cfg.Config
 
 	// Items already in the queue.
 	alreadyQ map[string]bool
@@ -114,13 +150,17 @@
 	}
 
 	r := &Resolver{
-		Handler:      &DefaultMissingPackageHandler{Missing: []string{}, Gopath: []string{}},
-		basedir:      basedir,
-		VendorDir:    vdir,
-		BuildContext: buildContext,
-		seen:         map[string]bool{},
-		alreadyQ:     map[string]bool{},
-		findCache:    map[string]*PkgInfo{},
+		Handler:        &DefaultMissingPackageHandler{Missing: []string{}, Gopath: []string{}},
+		VersionHandler: &DefaultVersionHandler{},
+		basedir:        basedir,
+		VendorDir:      vdir,
+		BuildContext:   buildContext,
+		seen:           map[string]bool{},
+		alreadyQ:       map[string]bool{},
+		findCache:      map[string]*PkgInfo{},
+
+		// The config instance here should really be replaced with a real one.
+		Config: &cfg.Config{},
 	}
 
 	// TODO: Make sure the build context is correctly set up. Especially in
@@ -246,6 +286,12 @@
 	var failedDep string
 	for e := queue.Front(); e != nil; e = e.Next() {
 		dep := e.Value.(string)
+		t := strings.TrimPrefix(e.Value.(string), r.VendorDir+string(os.PathSeparator))
+		if r.Config.HasIgnore(t) {
+			msg.Info("Ignoring: %s", t)
+			continue
+		}
+		r.VersionHandler.Process(t)
 		//msg.Warn("#### %s ####", dep)
 		//msg.Info("Seen Count: %d", len(r.seen))
 		// Catch the outtermost dependency.
@@ -282,7 +328,28 @@
 	}
 
 	res := make([]string, 0, queue.Len())
+
+	// In addition to generating a list
 	for e := queue.Front(); e != nil; e = e.Next() {
+		t := strings.TrimPrefix(e.Value.(string), r.VendorDir+string(os.PathSeparator))
+		root, sp := util.NormalizeName(t)
+
+		// TODO(mattfarina): Need to eventually support devImport
+		existing := r.Config.Imports.Get(root)
+		if existing != nil {
+			if sp != "" && !existing.HasSubpackage(sp) {
+				existing.Subpackages = append(existing.Subpackages, sp)
+			}
+		} else {
+			newDep := &cfg.Dependency{
+				Name: root,
+			}
+			if sp != "" {
+				newDep.Subpackages = []string{sp}
+			}
+
+			r.Config.Imports = append(r.Config.Imports, newDep)
+		}
 		res = append(res, e.Value.(string))
 	}
 
@@ -326,6 +393,11 @@
 // If it cannot resolve the pkg, it will return an error.
 func (r *Resolver) imports(pkg string) ([]string, error) {
 
+	if r.Config.HasIgnore(pkg) {
+		msg.Debug("Ignoring %s", pkg)
+		return []string{}, nil
+	}
+
 	// If this pkg is marked seen, we don't scan it again.
 	if _, ok := r.seen[pkg]; ok {
 		msg.Debug("Already saw %s", pkg)
@@ -353,6 +425,10 @@
 	// We are only looking for dependencies in vendor. No root, cgo, etc.
 	buf := []string{}
 	for _, imp := range p.Imports {
+		if r.Config.HasIgnore(imp) {
+			msg.Debug("Ignoring %s", imp)
+			continue
+		}
 		info := r.FindPkg(imp)
 		switch info.Loc {
 		case LocUnknown:
@@ -363,12 +439,14 @@
 			}
 			if found {
 				buf = append(buf, filepath.Join(r.VendorDir, filepath.FromSlash(imp)))
+				r.VersionHandler.SetVersion(imp)
 				continue
 			}
 			r.seen[info.Path] = true
 		case LocVendor:
 			//msg.Debug("Vendored: %s", imp)
 			buf = append(buf, info.Path)
+			r.VersionHandler.SetVersion(imp)
 		case LocGopath:
 			found, err := r.Handler.OnGopath(imp)
 			if err != nil {
@@ -379,6 +457,7 @@
 			// in a less-than-perfect, but functional, situation.
 			if found {
 				buf = append(buf, filepath.Join(r.VendorDir, filepath.FromSlash(imp)))
+				r.VersionHandler.SetVersion(imp)
 				continue
 			}
 			msg.Warn("Package %s is on GOPATH, but not vendored. Ignoring.", imp)
@@ -516,6 +595,13 @@
 	return fi.Mode()&os.ModeSymlink == os.ModeSymlink
 }
 
+// Returns true if this is a directory that could have source code, false otherwise.
+//
+// Directories with _ or . prefixes are skipped, as are testdata and vendor.
+func IsSrcDir(fi os.FileInfo) bool {
+	return srcDir(fi)
+}
+
 func srcDir(fi os.FileInfo) bool {
 	if !fi.IsDir() {
 		return false
diff --git a/dependency/resolver_test.go b/dependency/resolver_test.go
index 46268f2..0edb764 100644
--- a/dependency/resolver_test.go
+++ b/dependency/resolver_test.go
@@ -21,7 +21,6 @@
 	}
 
 	expect := []string{
-		"github.com/Masterminds/cookoo",
 		"github.com/Masterminds/semver",
 		"github.com/Masterminds/vcs",
 		"gopkg.in/yaml.v2",
@@ -53,8 +52,8 @@
 		t.Fatalf("Failed to resolve: %s", err)
 	}
 
-	if len(l) < 8 {
-		t.Errorf("Expected at least 8 deps, got %d: %s", len(l))
+	if len(l) < 4 {
+		t.Errorf("Expected at least 4 deps, got %d: %s", len(l))
 	}
 }
 
@@ -79,8 +78,8 @@
 	// These are build dependencies of Glide, so we know they are here.
 	deps := []*cfg.Dependency{
 		&cfg.Dependency{Name: "github.com/codegangsta/cli"},
-		&cfg.Dependency{Name: "github.com/Masterminds/cookoo"},
 		&cfg.Dependency{Name: "github.com/Masterminds/semver"},
+		&cfg.Dependency{Name: "github.com/Masterminds/vcs"},
 		&cfg.Dependency{Name: "gopkg.in/yaml.v2"},
 	}
 
diff --git a/gb/gb.go b/gb/gb.go
new file mode 100644
index 0000000..5a07c62
--- /dev/null
+++ b/gb/gb.go
@@ -0,0 +1,69 @@
+package gb
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	"github.com/Masterminds/glide/util"
+)
+
+// Returns true if this dir has a GB-flavored manifest file.
+func Has(dir string) bool {
+	path := filepath.Join(dir, "vendor/manifest")
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// Parse parses a GB-flavored manifest file.
+func Parse(dir string) ([]*cfg.Dependency, error) {
+	path := filepath.Join(dir, "vendor/manifest")
+	if fi, err := os.Stat(path); err != nil || fi.IsDir() {
+		return []*cfg.Dependency{}, nil
+	}
+
+	msg.Info("Found GB manifest file.\n")
+	buf := []*cfg.Dependency{}
+	file, err := os.Open(path)
+	if err != nil {
+		return buf, err
+	}
+	defer file.Close()
+
+	man := Manifest{}
+
+	dec := json.NewDecoder(file)
+	if err := dec.Decode(&man); err != nil {
+		return buf, err
+	}
+
+	seen := map[string]bool{}
+
+	for _, d := range man.Dependencies {
+		pkg, sub := util.NormalizeName(d.Importpath)
+		if _, ok := seen[pkg]; ok {
+			if len(sub) == 0 {
+				continue
+			}
+			for _, dep := range buf {
+				if dep.Name == pkg {
+					dep.Subpackages = append(dep.Subpackages, sub)
+				}
+			}
+		} else {
+			seen[pkg] = true
+			dep := &cfg.Dependency{
+				Name:       pkg,
+				Reference:  d.Revision,
+				Repository: d.Repository,
+			}
+			if len(sub) > 0 {
+				dep.Subpackages = []string{sub}
+			}
+			buf = append(buf, dep)
+		}
+	}
+	return buf, nil
+}
diff --git a/glide.go b/glide.go
index 0ecd89b..e7900a8 100644
--- a/glide.go
+++ b/glide.go
@@ -39,9 +39,10 @@
 import (
 	"path/filepath"
 
-	"github.com/Masterminds/glide/cmd"
+	"github.com/Masterminds/glide/action"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/glide/repo"
 
-	"github.com/Masterminds/cookoo"
 	"github.com/codegangsta/cli"
 
 	"fmt"
@@ -66,7 +67,7 @@
 		  subpackages: yaml
 			flatten: true
 
-NOTE: As of Glide 0.5, the commands 'in', 'into', 'gopath', 'status', and 'env'
+NOTE: As of Glide 0.5, the commands 'into', 'gopath', 'status', and 'env'
 no longer exist.
 `
 
@@ -74,11 +75,6 @@
 var VendorDir = "vendor"
 
 func main() {
-	reg, router, cxt := cookoo.Cookoo()
-	cxt.Put("VendorDir", VendorDir)
-
-	routes(reg, cxt)
-
 	app := cli.NewApp()
 	app.Name = "glide"
 	app.Usage = usage
@@ -109,17 +105,16 @@
 		},
 	}
 	app.CommandNotFound = func(c *cli.Context, command string) {
-		cxt.Put("os.Args", os.Args)
-		cxt.Put("command", command)
-		setupHandler(c, "@plugin", cxt, router)
+		// TODO: Set some useful env vars.
+		action.Plugin(command, os.Args)
 	}
-
-	app.Commands = commands(cxt, router)
+	app.Before = startup
+	app.Commands = commands()
 
 	app.Run(os.Args)
 }
 
-func commands(cxt cookoo.Context, router *cookoo.Router) []cli.Command {
+func commands() []cli.Command {
 	return []cli.Command{
 		{
 			Name:      "create",
@@ -139,8 +134,7 @@
 				},
 			},
 			Action: func(c *cli.Context) {
-				cxt.Put("skipImport", c.Bool("skip-import"))
-				setupHandler(c, "create", cxt, router)
+				action.Create(".", c.Bool("skip-import"))
 			},
 		},
 		{
@@ -198,21 +192,52 @@
 					fmt.Println("Oops! Package name is required.")
 					os.Exit(1)
 				}
-				cxt.Put("forceUpdate", c.Bool("force"))
-				cxt.Put("packages", []string(c.Args()))
-				cxt.Put("skipFlatten", !c.Bool("no-recursive"))
-				cxt.Put("insecure", c.Bool("insecure"))
-				cxt.Put("useCache", c.Bool("cache"))
-				cxt.Put("cacheGopath", c.Bool("cache-gopath"))
-				cxt.Put("useGopath", c.Bool("use-gopath"))
-				// FIXME: Are these used anywhere?
-				if c.Bool("import") {
-					cxt.Put("importGodeps", true)
-					cxt.Put("importGPM", true)
-					cxt.Put("importGb", true)
+
+				inst := &repo.Installer{
+					Force:          c.Bool("force"),
+					UseCache:       c.Bool("cache"),
+					UseGopath:      c.Bool("use-gopath"),
+					UseCacheGopath: c.Bool("cache-gopath"),
+					UpdateVendored: c.Bool("update-vendored"),
 				}
-				cxt.Put("updateVendoredDeps", c.Bool("update-vendored"))
-				setupHandler(c, "get", cxt, router)
+				packages := []string(c.Args())
+				insecure := c.Bool("insecure")
+				action.Get(packages, inst, insecure, c.Bool("no-recursive"))
+			},
+		},
+		{
+			Name:      "remove",
+			ShortName: "rm",
+			Usage:     "Remove a package from the glide.yaml file, and regenerate the lock file.",
+			Description: `This takes one or more package names, and removes references from the glide.yaml file.
+	This will rebuild the glide lock file with the following constraints:
+
+	- Dependencies are re-negotiated. Any that are no longer used are left out of the lock.
+	- Minor version re-nogotiation is performed on remaining dependencies.
+	- No updates are peformed. You may want to run 'glide up' to accomplish that.
+`,
+			Flags: []cli.Flag{
+				cli.BoolFlag{
+					Name:  "delete,d",
+					Usage: "Also delete from vendor/ any packages that are no longer used.",
+				},
+			},
+			Action: func(c *cli.Context) {
+				if len(c.Args()) < 1 {
+					fmt.Println("Oops! At least one package name is required.")
+					os.Exit(1)
+				}
+
+				if c.Bool("delete") {
+					// FIXME: Implement this in the installer.
+					fmt.Println("Delete is not currently implemented.")
+				}
+
+				inst := &repo.Installer{
+					Force: c.Bool("force"),
+				}
+				packages := []string(c.Args())
+				action.Remove(packages, inst)
 			},
 		},
 		{
@@ -229,8 +254,7 @@
 						},
 					},
 					Action: func(c *cli.Context) {
-						cxt.Put("toPath", c.String("file"))
-						setupHandler(c, "import godep", cxt, router)
+						action.ImportGodep(c.String("file"))
 					},
 				},
 				{
@@ -243,8 +267,7 @@
 						},
 					},
 					Action: func(c *cli.Context) {
-						cxt.Put("toPath", c.String("file"))
-						setupHandler(c, "import gpm", cxt, router)
+						action.ImportGPM(c.String("file"))
 					},
 				},
 				{
@@ -257,8 +280,7 @@
 						},
 					},
 					Action: func(c *cli.Context) {
-						cxt.Put("toPath", c.String("file"))
-						setupHandler(c, "import gb", cxt, router)
+						action.ImportGB(c.String("file"))
 					},
 				},
 			},
@@ -268,7 +290,7 @@
 			Usage:       "Print the name of this project.",
 			Description: `Read the glide.yaml file and print the name given on the 'package' line.`,
 			Action: func(c *cli.Context) {
-				setupHandler(c, "name", cxt, router)
+				action.Name()
 			},
 		},
 		{
@@ -281,40 +303,28 @@
 
 			$ go test $(glide novendor)
 `,
+			Flags: []cli.Flag{
+				cli.StringFlag{
+					Name:  "dir,d",
+					Usage: "Specify a directory to run novendor against.",
+					Value: ".",
+				},
+				cli.BoolFlag{
+					Name:  "no-subdir,x",
+					Usage: "Specify this to prevent nv from append '/...' to all directories.",
+				},
+			},
 			Action: func(c *cli.Context) {
-				setupHandler(c, "nv", cxt, router)
+				action.NoVendor(c.String("dir"), true, !c.Bool("no-subdir"))
 			},
 		},
-		// 	{
-		// 		Name:  "pin",
-		// 		Usage: "Print a YAML file with all of the packages pinned to the current version",
-		// 		Description: `Begins with the current glide.yaml and sets an absolute ref
-		// for every package. The version is derived from the repository version. It will be
-		// either a commit or a tag, depending on the state of the VCS tree.
-		//
-		// By default, output is written to standard out. However, if you supply a filename,
-		// the data will be written to that:
-		//
-		//     $ glide pin glide.yaml
-		//
-		// The above will overwrite your glide.yaml file. You have been warned.
-		// `,
-		// 		Action: func(c *cli.Context) {
-		// 			outfile := ""
-		// 			if len(c.Args()) == 1 {
-		// 				outfile = c.Args()[0]
-		// 			}
-		// 			cxt.Put("toPath", outfile)
-		// 			setupHandler(c, "pin", cxt, router)
-		// 		},
-		// 	},
 		{
 			Name:  "rebuild",
 			Usage: "Rebuild ('go build') the dependencies",
 			Description: `This rebuilds the packages' '.a' files. On some systems
 	this can improve performance on subsequent 'go run' and 'go build' calls.`,
 			Action: func(c *cli.Context) {
-				setupHandler(c, "rebuild", cxt, router)
+				action.Rebuild()
 			},
 		},
 		{
@@ -334,20 +344,16 @@
 					Usage: "Delete vendor packages not specified in config.",
 				},
 				cli.BoolFlag{
-					Name:  "no-recursive, quick",
-					Usage: "Disable updating dependencies' dependencies. Only update things in glide.yaml.",
-				},
-				cli.BoolFlag{
 					Name:  "force",
-					Usage: "If there was a change in the repo or VCS switch to new one. Warning, changes will be lost.",
+					Usage: "If there was a change in the repo or VCS switch to new one. Warning: changes will be lost.",
 				},
 				cli.BoolFlag{
 					Name:  "update-vendored, u",
-					Usage: "Update vendored packages (without local VCS repo). Warning, changes will be lost.",
+					Usage: "Update vendored packages (without local VCS repo). Warning: this may destroy local modifications to vendor/.",
 				},
 				cli.StringFlag{
 					Name:  "file, f",
-					Usage: "Save all of the discovered dependencies to a Glide YAML file.",
+					Usage: "Save all of the discovered dependencies to a Glide YAML file. (DEPRECATED: This has no impact.)",
 				},
 				cli.BoolFlag{
 					Name:  "cache",
@@ -363,24 +369,17 @@
 				},
 			},
 			Action: func(c *cli.Context) {
-				cxt.Put("deleteOptIn", c.Bool("delete"))
-				cxt.Put("forceUpdate", c.Bool("force"))
-				cxt.Put("skipFlatten", c.Bool("no-recursive"))
-				cxt.Put("deleteFlatten", c.Bool("delete-flatten"))
-				cxt.Put("toPath", c.String("file"))
-				cxt.Put("toStdout", false)
-				cxt.Put("useCache", c.Bool("cache"))
-				cxt.Put("cacheGopath", c.Bool("cache-gopath"))
-				cxt.Put("useGopath", c.Bool("use-gopath"))
-				if c.Bool("import") {
-					cxt.Put("importGodeps", true)
-					cxt.Put("importGPM", true)
-					cxt.Put("importGb", true)
+				installer := &repo.Installer{
+					DeleteUnused:   c.Bool("deleteOptIn"),
+					UpdateVendored: c.Bool("update-vendored"),
+					Force:          c.Bool("force"),
+					UseCache:       c.Bool("cache"),
+					UseCacheGopath: c.Bool("cache-gopath"),
+					UseGopath:      c.Bool("use-gopath"),
+					Home:           gpath.Home(),
 				}
-				cxt.Put("updateVendoredDeps", c.Bool("update-vendored"))
 
-				cxt.Put("packages", []string(c.Args()))
-				setupHandler(c, "install", cxt, router)
+				action.Install(installer)
 			},
 		},
 		{
@@ -447,24 +446,17 @@
 				},
 			},
 			Action: func(c *cli.Context) {
-				cxt.Put("deleteOptIn", c.Bool("delete"))
-				cxt.Put("forceUpdate", c.Bool("force"))
-				cxt.Put("skipFlatten", c.Bool("no-recursive"))
-				cxt.Put("deleteFlatten", c.Bool("delete-flatten"))
-				cxt.Put("toPath", c.String("file"))
-				cxt.Put("toStdout", false)
-				cxt.Put("useCache", c.Bool("cache"))
-				cxt.Put("cacheGopath", c.Bool("cache-gopath"))
-				cxt.Put("useGopath", c.Bool("use-gopath"))
-				if c.Bool("import") {
-					cxt.Put("importGodeps", true)
-					cxt.Put("importGPM", true)
-					cxt.Put("importGb", true)
+				installer := &repo.Installer{
+					DeleteUnused:   c.Bool("deleteOptIn"),
+					UpdateVendored: c.Bool("update-vendored"),
+					Force:          c.Bool("force"),
+					UseCache:       c.Bool("cache"),
+					UseCacheGopath: c.Bool("cache-gopath"),
+					UseGopath:      c.Bool("use-gopath"),
+					Home:           gpath.Home(),
 				}
-				cxt.Put("updateVendoredDeps", c.Bool("update-vendored"))
 
-				cxt.Put("packages", []string(c.Args()))
-				setupHandler(c, "update", cxt, router)
+				action.Update(installer, c.Bool("no-recursive"))
 			},
 		},
 		{
@@ -477,7 +469,7 @@
 	vendor/ are only included if they are referenced by the main project or
 	one of its dependencies.`,
 			Action: func(c *cli.Context) {
-				setupHandler(c, "tree", cxt, router)
+				action.Tree(".", false)
 			},
 		},
 		{
@@ -492,247 +484,19 @@
 			vendor are only included if they are used by the project.
 			`,
 			Action: func(c *cli.Context) {
-				setupHandler(c, "list", cxt, router)
+				action.List(".", true)
 			},
 		},
 		{
 			Name:  "about",
 			Usage: "Learn about Glide",
 			Action: func(c *cli.Context) {
-				setupHandler(c, "about", cxt, router)
+				action.About()
 			},
 		},
 	}
 }
 
-func setupHandler(c *cli.Context, route string, cxt cookoo.Context, router *cookoo.Router) {
-	cxt.Put("q", c.GlobalBool("quiet"))
-	cxt.Put("debug", c.GlobalBool("debug"))
-	cxt.Put("no-color", c.GlobalBool("no-color"))
-	cxt.Put("yaml", c.GlobalString("yaml"))
-	cxt.Put("home", c.GlobalString("home"))
-	cxt.Put("cliArgs", c.Args())
-	if err := router.HandleRequest(route, cxt, false); err != nil {
-		fmt.Printf("Oops! %s\n", err)
-		os.Exit(1)
-	}
-}
-
-func routes(reg *cookoo.Registry, cxt cookoo.Context) {
-	reg.Route("@startup", "Parse args and send to the right subcommand.").
-		// TODO: Add setup for debug in addition to quiet.
-		Does(cmd.BeQuiet, "quiet").
-		Using("quiet").From("cxt:q").
-		Using("debug").From("cxt:debug").
-		Does(cmd.CheckColor, "no-color").
-		Using("no-color").From("cxt:no-color").
-		Does(cmd.VersionGuard, "v")
-
-	reg.Route("@ready", "Prepare for glide commands.").
-		Does(cmd.ReadyToGlide, "ready").Using("filename").From("cxt:yaml").
-		Does(cmd.ParseYaml, "cfg").Using("filename").From("cxt:yaml").
-		Does(cmd.EnsureCacheDir, "_").Using("home").From("cxt:home")
-
-	reg.Route("get", "Install a pkg in vendor, and store the results in the glide.yaml").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.CowardMode, "_").
-		Does(cmd.GetAll, "goget").
-		Using("packages").From("cxt:packages").
-		Using("conf").From("cxt:cfg").
-		Using("insecure").From("cxt:insecure").
-		Does(cmd.VendoredSetup, "cfg").
-		Using("conf").From("cxt:cfg").
-		Using("update").From("cxt:updateVendoredDeps").
-		Does(cmd.UpdateImports, "dependencies").
-		Using("conf").From("cxt:cfg").
-		Using("force").From("cxt:forceUpdate").
-		//Using("packages").From("cxt:packages").
-		Using("home").From("cxt:home").
-		Using("cache").From("cxt:useCache").
-		Using("cacheGopath").From("cxt:cacheGopath").
-		Using("useGopath").From("cxt:useGopath").
-		Does(cmd.SetReference, "version").Using("conf").From("cxt:cfg").
-		Does(cmd.Flatten, "flattened").Using("conf").From("cxt:cfg").
-		//Using("packages").From("cxt:packages").
-		Using("force").From("cxt:forceUpdate").
-		Using("home").From("cxt:home").
-		Using("cache").From("cxt:useCache").
-		Using("cacheGopath").From("cxt:cacheGopath").
-		Using("useGopath").From("cxt:useGopath").
-		Does(cmd.VendoredCleanUp, "_").
-		Using("conf").From("cxt:flattened").
-		Using("update").From("cxt:updateVendoredDeps").
-		Does(cmd.WriteYaml, "out").
-		Using("conf").From("cxt:cfg").
-		Using("filename").WithDefault("glide.yaml").From("cxt:yaml").
-		Does(cmd.WriteLock, "lock").
-		Using("lockfile").From("cxt:Lockfile")
-
-	reg.Route("install", "Install dependencies.").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.CowardMode, "_").
-		Does(cmd.LockFileExists, "_").
-		Does(cmd.LoadLockFile, "lock").
-		Using("conf").From("cxt:cfg").
-		Does(cmd.Mkdir, "dir").Using("dir").WithDefault(VendorDir).
-		Does(cmd.DeleteUnusedPackages, "deleted").
-		Using("conf").From("cxt:cfg").
-		Using("optIn").From("cxt:deleteOptIn").
-		Does(cmd.VendoredSetup, "cfg").
-		Using("conf").From("cxt:cfg").
-		Using("update").From("cxt:updateVendoredDeps").
-		Does(cmd.Install, "icfg").
-		Using("conf").From("cxt:cfg").
-		Using("lock").From("cxt:lock").
-		Using("home").From("cxt:home").
-		Does(cmd.SetReference, "version").Using("conf").From("cxt:icfg").
-		Does(cmd.VendoredCleanUp, "_").
-		Using("conf").From("cxt:icfg").
-		Using("update").From("cxt:updateVendoredDeps")
-
-	reg.Route("update", "Update dependencies.").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.CowardMode, "_").
-		Does(cmd.Mkdir, "dir").Using("dir").WithDefault(VendorDir).
-		Does(cmd.DeleteUnusedPackages, "deleted").
-		Using("conf").From("cxt:cfg").
-		Using("optIn").From("cxt:deleteOptIn").
-		Does(cmd.VendoredSetup, "cfg").
-		Using("conf").From("cxt:cfg").
-		Using("update").From("cxt:updateVendoredDeps").
-		Does(cmd.UpdateImports, "dependencies").
-		Using("conf").From("cxt:cfg").
-		Using("force").From("cxt:forceUpdate").
-		Using("packages").From("cxt:packages").
-		Using("home").From("cxt:home").
-		Using("cache").From("cxt:useCache").
-		Using("cacheGopath").From("cxt:cacheGopath").
-		Using("useGopath").From("cxt:useGopath").
-		Does(cmd.SetReference, "version").Using("conf").From("cxt:cfg").
-		Does(cmd.Flatten, "flattened").Using("conf").From("cxt:cfg").
-		//Using("packages").From("cxt:packages").
-		Using("force").From("cxt:forceUpdate").
-		Using("skip").From("cxt:skipFlatten").
-		Using("home").From("cxt:home").
-		Using("cache").From("cxt:useCache").
-		Using("cacheGopath").From("cxt:cacheGopath").
-		Using("useGopath").From("cxt:useGopath").
-		Does(cmd.VendoredCleanUp, "_").
-		Using("conf").From("cxt:flattened").
-		Using("update").From("cxt:updateVendoredDeps").
-		Does(cmd.WriteYaml, "out").
-		Using("conf").From("cxt:cfg").
-		Using("filename").From("cxt:toPath").
-		Using("toStdout").From("cxt:toStdout").
-		Does(cmd.WriteLock, "lock").
-		Using("lockfile").From("cxt:Lockfile").
-		Using("skip").From("cxt:skipFlatten")
-
-	//Does(cmd.Rebuild, "rebuild").Using("conf").From("cxt:cfg")
-
-	reg.Route("rebuild", "Rebuild dependencies").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.CowardMode, "_").
-		Does(cmd.Rebuild, "rebuild").Using("conf").From("cxt:cfg")
-
-	reg.Route("pin", "Print a YAML file with all of the packages pinned to the current version.").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.Flatten, "flattened").Using("conf").From("cxt:cfg").
-		Using("packages").From("cxt:packages").
-		Using("force").From("cxt:forceUpdate").
-		Using("skip").From("cxt:skipFlatten").
-		Using("home").From("cxt:home").
-		Using("cache").From("cxt:useCache").
-		Using("cacheGopath").From("cxt:cacheGopath").
-		Using("useGopath").From("cxt:useGopath").
-		//Does(cmd.VendoredCleanUp, "_").
-		//Using("conf").From("cxt:flattened").
-		//Using("update").From("cxt:updateVendoredDeps").
-		// Write the Lockfile
-		Does(cmd.WriteYaml, "out").
-		Using("conf").From("cxt:Lockfile").
-		Using("filename").From("cxt:toPath").
-		Using("toStdout").From("cxt:toStdout")
-
-	reg.Route("import gpm", "Read a Godeps file").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.GPMGodeps, "godeps").
-		Does(cmd.AddDependencies, "addGodeps").
-		Using("dependencies").From("cxt:godeps").
-		Using("conf").From("cxt:cfg").
-		Does(cmd.GPMGodepsGit, "godepsGit").
-		Does(cmd.AddDependencies, "addGodepsGit").
-		Using("dependencies").From("cxt:godepsGit").
-		Using("conf").From("cxt:cfg").
-		// Does(cmd.UpdateReferences, "refs").Using("conf").From("cxt:cfg").
-		Does(cmd.WriteYaml, "out").Using("conf").From("cxt:cfg").
-		Using("filename").From("cxt:toPath")
-
-	reg.Route("import godep", "Read a Godeps.json file").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.ParseGodepGodeps, "godeps").
-		Does(cmd.AddDependencies, "addGodeps").
-		Using("dependencies").From("cxt:godeps").
-		Using("conf").From("cxt:cfg").
-		// Does(cmd.UpdateReferences, "refs").Using("conf").From("cxt:cfg").
-		Does(cmd.WriteYaml, "out").Using("conf").From("cxt:cfg").
-		Using("filename").From("cxt:toPath")
-
-	reg.Route("import gb", "Read a vendor/manifest file").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.GbManifest, "manifest").
-		Does(cmd.AddDependencies, "addGodeps").
-		Using("dependencies").From("cxt:manifest").
-		Using("conf").From("cxt:cfg").
-		Does(cmd.WriteYaml, "out").Using("conf").From("cxt:cfg").
-		Using("filename").From("cxt:toPath")
-
-	reg.Route("create", "Guess dependencies").
-		Includes("@startup").
-		Does(cmd.GuardYaml, "_").
-		Using("filename").From("cxt:yaml").
-		Does(cmd.GuessDeps, "cfg").
-		Using("skipImport").From("cxt:skipImport").
-		Does(cmd.WriteYaml, "out").
-		Using("conf").From("cxt:cfg").
-		Using("filename").From("cxt:yaml")
-
-	reg.Route("name", "Print environment").
-		Includes("@startup").
-		Includes("@ready").
-		Does(cmd.PrintName, "status").
-		Using("conf").From("cxt:cfg")
-
-	reg.Route("tree", "Print a dependency graph.").
-		Includes("@startup").
-		Does(cmd.Tree, "tree")
-	reg.Route("list", "Print a dependency graph.").
-		Includes("@startup").
-		Does(cmd.ListDeps, "list")
-
-	reg.Route("nv", "No Vendor").
-		Includes("@startup").
-		Does(cmd.NoVendor, "paths").
-		Does(cmd.PathString, "out").Using("paths").From("cxt:paths")
-
-	reg.Route("about", "Status").
-		Includes("@startup").
-		Does(cmd.About, "about")
-
-	reg.Route("@plugin", "Try to send to a plugin.").
-		Includes("@ready").
-		Does(cmd.DropToShell, "plugin").
-		Using("command").From("cxt:command")
-}
-
 func defaultGlideDir() string {
 	c, err := user.Current()
 	if err != nil {
@@ -740,3 +504,35 @@
 	}
 	return filepath.Join(c.HomeDir, ".glide")
 }
+
+// startup sets up the base environment.
+//
+// It does not assume the presence of a Glide.yaml file or vendor/ directory,
+// so it can be used by any Glide command.
+func startup(c *cli.Context) error {
+	action.Debug(c.Bool("debug"))
+	action.NoColor(c.Bool("no-color"))
+	action.Quiet(c.Bool("quiet"))
+	action.Init(c.String("yaml"), c.String("home"))
+	action.EnsureGoVendor()
+	return nil
+}
+
+// Get the path to the glide.yaml file.
+//
+// This returns the name of the path, even if the file does not exist. The value
+// may be set by the user, or it may be the default.
+func glidefile(c *cli.Context) string {
+	path := c.String("file")
+	if path == "" {
+		// For now, we construct a basic assumption. In the future, we could
+		// traverse backward to see if a glide.yaml exists in a parent.
+		path = "./glide.yaml"
+	}
+	a, err := filepath.Abs(path)
+	if err != nil {
+		// Underlying fs didn't provide working dir.
+		return path
+	}
+	return a
+}
diff --git a/glide.lock b/glide.lock
index cd88888..3ff76ad 100644
--- a/glide.lock
+++ b/glide.lock
@@ -1,14 +1,10 @@
-hash: foo
-updated: 2015-12-21T09:29:33.170992254-05:00
+hash: 4cf59f8e61ae7034d3296c0c7528aaf8784800008814fb02410cbb3ea9b34175
+updated: 2016-01-21T11:19:37.465408253-05:00
 imports:
 - name: github.com/codegangsta/cli
-  version: b5232bb2934f606f9f27a1305f1eea224e8e8b88
-- name: github.com/Masterminds/cookoo
-  version: 78aa11ce75e257c51be7ea945edb84cf19c4a6de
-  subpackages:
-  - .
+  version: c31a7975863e7810c92e2e288a9ab074f9a88f29
 - name: github.com/Masterminds/semver
-  version: 6333b7bd29aad1d79898ff568fd90a8aa533ae82
+  version: 513f3dcb3ecfb1248831fb5cb06a23a3cd5935dc
 - name: github.com/Masterminds/vcs
   version: eaee272c8fa4514e1572e182faecff5be20e792a
 - name: gopkg.in/yaml.v2
diff --git a/glide.yaml b/glide.yaml
index c888aa0..611d71c 100644
--- a/glide.yaml
+++ b/glide.yaml
@@ -1,10 +1,6 @@
 package: github.com/Masterminds/glide
 import:
 - package: gopkg.in/yaml.v2
-- package: github.com/Masterminds/cookoo
-  version: ^1.2.0
-  subpackages:
-  - .
 - package: github.com/Masterminds/vcs
   version: ^1.2.0
 - package: github.com/codegangsta/cli
diff --git a/glide_test.go b/glide_test.go
index 9e0a838..1c50468 100644
--- a/glide_test.go
+++ b/glide_test.go
@@ -2,13 +2,10 @@
 
 import (
 	"testing"
-
-	"github.com/Masterminds/cookoo"
 )
 
 func TestCommandsNonEmpty(t *testing.T) {
-	_, router, ctx := cookoo.Cookoo()
-	commands := commands(ctx, router)
+	commands := commands()
 	if len(commands) == 0 {
 		t.Fail()
 	}
diff --git a/cmd/godeps.go b/godep/godep.go
similarity index 65%
rename from cmd/godeps.go
rename to godep/godep.go
index ac12292..b39deca 100644
--- a/cmd/godeps.go
+++ b/godep/godep.go
@@ -1,4 +1,8 @@
-package cmd
+/* Package godep provides basic importing of Godep dependencies.
+
+This is not a complete implementation of Godep.
+*/
+package godep
 
 import (
 	"encoding/json"
@@ -6,8 +10,8 @@
 	"path/filepath"
 	"strings"
 
-	"github.com/Masterminds/cookoo"
 	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
 	"github.com/Masterminds/glide/util"
 )
 
@@ -35,34 +39,26 @@
 	Rev        string // VCS-specific commit ID.
 }
 
-// HasGodepGodeps is a command to detect if a package contains a Godeps.json file.
-func HasGodepGodeps(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	dir := cookoo.GetString("dir", "", p)
-	path := filepath.Join(dir, "Godeps", "Godeps.json")
+// Has is a command to detect if a package contains a Godeps.json file.
+func Has(dir string) bool {
+	path := filepath.Join(dir, "Godeps/Godeps.json")
 	_, err := os.Stat(path)
-	return err == nil, nil
+	return err == nil
 }
 
-// ParseGodepGodeps parses the Godep Godeps.json file.
+// Parse parses a Godep's Godeps file.
 //
-// Params:
-// - dir (string): the project's directory
-//
-// Returns an []*cfg.Dependency
-func ParseGodepGodeps(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
-	dir := cookoo.GetString("dir", "", p)
-	return parseGodepGodeps(dir)
-}
-func parseGodepGodeps(dir string) ([]*cfg.Dependency, error) {
-	path := filepath.Join(dir, "Godeps", "Godeps.json")
+// It returns the contents as a dependency array.
+func Parse(dir string) ([]*cfg.Dependency, error) {
+	path := filepath.Join(dir, "Godeps/Godeps.json")
 	if _, err := os.Stat(path); err != nil {
 		return []*cfg.Dependency{}, nil
 	}
-	Info("Found Godeps.json file.\n")
+	msg.Info("Found Godeps.json file.\n")
 
 	buf := []*cfg.Dependency{}
 
-	godeps := new(Godeps)
+	godeps := &Godeps{}
 
 	// Get a handle to the file.
 	file, err := os.Open(path)
@@ -76,11 +72,8 @@
 		return buf, err
 	}
 
-	// Info("Importing %d packages from %s.\n", len(godeps.Deps), godeps.ImportPath)
 	seen := map[string]bool{}
-
 	for _, d := range godeps.Deps {
-		// Info("Adding package %s\n", d.ImportPath)
 		pkg := util.GetRootFromPackage(d.ImportPath)
 		sub := strings.TrimPrefix(d.ImportPath, pkg)
 		sub = strings.TrimPrefix(sub, "/")
diff --git a/gpm/gpm.go b/gpm/gpm.go
new file mode 100644
index 0000000..41de69d
--- /dev/null
+++ b/gpm/gpm.go
@@ -0,0 +1,68 @@
+/* Package gpm reads GPM's Godeps files.
+
+It is not a complete implementaton of GPM.
+*/
+package gpm
+
+import (
+	"bufio"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+)
+
+// Has indicates whether a Godeps file exists.
+func Has(dir string) bool {
+	path := filepath.Join(dir, "Godeps")
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// Parse parses a GPM-flavored Godeps file.
+func Parse(dir string) ([]*cfg.Dependency, error) {
+	path := filepath.Join(dir, "Godeps")
+	if i, err := os.Stat(path); err != nil {
+		return []*cfg.Dependency{}, nil
+	} else if i.IsDir() {
+		msg.Info("Godeps is a directory. This is probably a Godep project.\n")
+		return []*cfg.Dependency{}, nil
+	}
+	msg.Info("Found Godeps file.\n")
+
+	buf := []*cfg.Dependency{}
+
+	file, err := os.Open(path)
+	if err != nil {
+		return buf, err
+	}
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		parts, ok := parseGodepsLine(scanner.Text())
+		if ok {
+			dep := &cfg.Dependency{Name: parts[0]}
+			if len(parts) > 1 {
+				dep.Reference = parts[1]
+			}
+			buf = append(buf, dep)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		msg.Warn("Scan failed: %s\n", err)
+		return buf, err
+	}
+
+	return buf, nil
+}
+
+func parseGodepsLine(line string) ([]string, bool) {
+	line = strings.TrimSpace(line)
+
+	if len(line) == 0 || strings.HasPrefix(line, "#") {
+		return []string{}, false
+	}
+
+	return strings.Fields(line), true
+}
diff --git a/importer/importer.go b/importer/importer.go
new file mode 100644
index 0000000..51a9ba5
--- /dev/null
+++ b/importer/importer.go
@@ -0,0 +1,82 @@
+// Package importer imports dependency configuration from Glide, Godep, GPM, and GB
+package importer
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/gb"
+	"github.com/Masterminds/glide/godep"
+	"github.com/Masterminds/glide/gpm"
+)
+
+var i = &DefaultImporter{}
+
+// Import uses the DefaultImporter to import from Glide, Godep, GPM, and GB.
+func Import(path string) (bool, []*cfg.Dependency, error) {
+	return i.Import(path)
+}
+
+// Importer enables importing depenency configuration.
+type Importer interface {
+
+	// Import imports dependency configuration. It returns:
+	// - A bool if any configuration was found.
+	// - []*cfg.Dependency containing dependency configuration if any is found.
+	// - An error if one was reported.
+	Import(path string) (bool, []*cfg.Dependency, error)
+}
+
+// DefaultImporter imports from Glide, Godep, GPM, and GB.
+type DefaultImporter struct{}
+
+// Import tries to import configuration from Glide, Godep, GPM, and GB.
+func (d *DefaultImporter) Import(path string) (bool, []*cfg.Dependency, error) {
+
+	// Try importing from Glide first.
+	p := filepath.Join(path, "glide.yaml")
+	if _, err := os.Stat(p); err == nil {
+		// We found glide configuration.
+		yml, err := ioutil.ReadFile(p)
+		if err != nil {
+			return false, []*cfg.Dependency{}, err
+		}
+		conf, err := cfg.ConfigFromYaml(yml)
+		if err != nil {
+			return false, []*cfg.Dependency{}, err
+		}
+		return true, conf.Imports, nil
+	}
+
+	// Try importing from Godep
+	if godep.Has(path) {
+		deps, err := godep.Parse(path)
+		if err != nil {
+			return false, []*cfg.Dependency{}, err
+		}
+		return true, deps, nil
+	}
+
+	// Try importing from GPM
+	if gpm.Has(path) {
+		deps, err := gpm.Parse(path)
+		if err != nil {
+			return false, []*cfg.Dependency{}, err
+		}
+		return true, deps, nil
+	}
+
+	// Try importin from GB
+	if gb.Has(path) {
+		deps, err := gb.Parse(path)
+		if err != nil {
+			return false, []*cfg.Dependency{}, err
+		}
+		return true, deps, nil
+	}
+
+	// When none are found.
+	return false, []*cfg.Dependency{}, nil
+}
diff --git a/msg/msg.go b/msg/msg.go
index a357a39..880afb5 100644
--- a/msg/msg.go
+++ b/msg/msg.go
@@ -1,92 +1,214 @@
-// +build !windows
-
 package msg
 
 import (
 	"fmt"
+	"io"
+	"os"
 	"strings"
+	"sync"
 )
 
-// These contanstants map to color codes for shell scripts making them
-// human readable.
-const (
-	Blue   = "0;34"
-	Red    = "0;31"
-	Green  = "0;32"
-	Yellow = "0;33"
-	Cyan   = "0;36"
-	Pink   = "1;35"
-)
+// Messanger provides the underlying implementation that displays output to
+// users.
+type Messanger struct {
+	sync.Mutex
 
-// Color returns a string in a certain color. The first argument is a string
-// containing the color code or a constant from the table above mapped to a code.
-//
-// The following will print the string "Foo" in yellow:
-//     fmt.Print(Color(Yellow, "Foo"))
-func Color(code, msg string) string {
-	if NoColor {
-		return msg
-	}
-	return fmt.Sprintf("\033[%sm%s\033[m", code, msg)
+	// Quiet, if true, suppresses chatty levels, like Info.
+	Quiet bool
+
+	// IsDebugging, if true, shows verbose levels, like Debug.
+	IsDebugging bool
+
+	// NoColor, if true, will not use color in the output.
+	NoColor bool
+
+	// Stdout is the location where this prints output.
+	Stdout io.Writer
+
+	// Stderr is the location where this prints logs.
+	Stderr io.Writer
+
+	// PanicOnDie if true Die() will panic instead of exiting.
+	PanicOnDie bool
+
+	// The default exit code to use when dyping
+	ecode int
 }
 
+// NewMessanger creates a default Messanger to display output.
+func NewMessanger() *Messanger {
+	m := &Messanger{
+		Quiet:       false,
+		IsDebugging: false,
+		NoColor:     false,
+		Stdout:      os.Stdout,
+		Stderr:      os.Stderr,
+		PanicOnDie:  false,
+		ecode:       1,
+	}
+
+	return m
+}
+
+// Default contains a default messanger used by package level functions
+var Default = NewMessanger()
+
 // Info logs information
-func Info(msg string, args ...interface{}) {
-	if Quiet {
+func (m *Messanger) Info(msg string, args ...interface{}) {
+	if m.Quiet {
 		return
 	}
-	fmt.Fprint(Stderr, Color(Green, "[INFO] "))
-	Msg(msg, args...)
+	prefix := m.Color(Green, "[INFO] ")
+	m.Msg(prefix+msg, args...)
+}
+
+// Info logs information using the Default Messanger
+func Info(msg string, args ...interface{}) {
+	Default.Info(msg, args...)
 }
 
 // Debug logs debug information
-func Debug(msg string, args ...interface{}) {
-	if Quiet || !IsDebugging {
+func (m *Messanger) Debug(msg string, args ...interface{}) {
+	if m.Quiet || !m.IsDebugging {
 		return
 	}
-	fmt.Fprint(Stderr, "[DEBUG] ")
-	Msg(msg, args...)
+	prefix := "[DEBUG] "
+	Msg(prefix+msg, args...)
+}
+
+// Debug logs debug information using the Default Messanger
+func Debug(msg string, args ...interface{}) {
+	Default.Debug(msg, args...)
 }
 
 // Warn logs a warning
+func (m *Messanger) Warn(msg string, args ...interface{}) {
+	prefix := m.Color(Yellow, "[WARN] ")
+	m.Msg(prefix+msg, args...)
+}
+
+// Warn logs a warning using the Default Messanger
 func Warn(msg string, args ...interface{}) {
-	fmt.Fprint(Stderr, Color(Yellow, "[WARN] "))
-	ErrMsg(msg, args...)
+	Default.Warn(msg, args...)
 }
 
 // Error logs and error.
-func Error(msg string, args ...interface{}) {
-	fmt.Fprint(Stderr, Color(Red, "[ERROR] "))
-	ErrMsg(msg, args...)
+func (m *Messanger) Error(msg string, args ...interface{}) {
+	prefix := m.Color(Red, "[ERROR] ")
+	m.Msg(prefix+msg, args...)
 }
 
-// ErrMsg sends a message to Stderr
-func ErrMsg(msg string, args ...interface{}) {
-	if len(args) == 0 {
-		fmt.Fprint(Stderr, msg)
-	} else {
-		fmt.Fprintf(Stderr, msg, args...)
-	}
+// Error logs and error using the Default Messanger
+func Error(msg string, args ...interface{}) {
+	Default.Error(msg, args...)
+}
 
-	// Get rid of the annoying fact that messages need \n at the end, but do
-	// it in a backward compatible way.
-	if !strings.HasSuffix(msg, "\n") {
-		fmt.Fprintln(Stderr)
+// Die prints an error message and immediately exits the application.
+// If PanicOnDie is set to true a panic will occur instead of os.Exit being
+// called.
+func (m *Messanger) Die(msg string, args ...interface{}) {
+	m.Error(msg, args...)
+	if m.PanicOnDie {
+		panic("trapped a Die() call")
 	}
+	os.Exit(m.ecode)
+}
+
+// Die prints an error message and immediately exits the application using the
+// Default Messanger. If PanicOnDie is set to true a panic will occur instead of
+// os.Exit being called.
+func Die(msg string, args ...interface{}) {
+	Default.Die(msg, args...)
+}
+
+// ExitCode sets the exit code used by Die.
+//
+// The default is 1.
+//
+// Returns the old error code.
+func (m *Messanger) ExitCode(e int) int {
+	m.Lock()
+	old := m.ecode
+	m.ecode = e
+	m.Unlock()
+	return old
+}
+
+// ExitCode sets the exit code used by Die using the Default Messanger.
+//
+// The default is 1.
+//
+// Returns the old error code.
+func ExitCode(e int) int {
+	return Default.ExitCode(e)
 }
 
 // Msg prints a message with optional arguments, that can be printed, of
 // varying types.
-func Msg(msg string, args ...interface{}) {
-	if len(args) == 0 {
-		fmt.Fprint(Stderr, msg)
-	} else {
-		fmt.Fprintf(Stderr, msg, args...)
-	}
+func (m *Messanger) Msg(msg string, args ...interface{}) {
+	// When operations in Glide are happening concurrently messaging needs to be
+	// locked to avoid displaying one message in the middle of another one.
+	m.Lock()
+	defer m.Unlock()
 
 	// Get rid of the annoying fact that messages need \n at the end, but do
 	// it in a backward compatible way.
 	if !strings.HasSuffix(msg, "\n") {
-		fmt.Fprintln(Stderr)
+		msg += "\n"
 	}
+
+	if len(args) == 0 {
+		fmt.Fprint(m.Stderr, msg)
+	} else {
+		fmt.Fprintf(m.Stderr, msg, args...)
+	}
+}
+
+// Msg prints a message with optional arguments, that can be printed, of
+// varying types using the Default Messanger.
+func Msg(msg string, args ...interface{}) {
+	Default.Msg(msg, args...)
+}
+
+// Puts formats a message and then prints to Stdout.
+//
+// It does not prefix the message, does not color it, or otherwise decorate it.
+//
+// It does add a line feed.
+func (m *Messanger) Puts(msg string, args ...interface{}) {
+	// When operations in Glide are happening concurrently messaging needs to be
+	// locked to avoid displaying one message in the middle of another one.
+	m.Lock()
+	defer m.Unlock()
+
+	fmt.Fprintf(m.Stdout, msg, args...)
+	fmt.Fprintln(m.Stdout)
+}
+
+// Puts formats a message and then prints to Stdout using the Default Messanger.
+//
+// It does not prefix the message, does not color it, or otherwise decorate it.
+//
+// It does add a line feed.
+func Puts(msg string, args ...interface{}) {
+	Default.Puts(msg, args...)
+}
+
+// Print prints exactly the string given.
+//
+// It prints to Stdout.
+func (m *Messanger) Print(msg string) {
+	// When operations in Glide are happening concurrently messaging needs to be
+	// locked to avoid displaying one message in the middle of another one.
+	m.Lock()
+	defer m.Unlock()
+
+	fmt.Fprint(m.Stdout, msg)
+}
+
+// Print prints exactly the string given using the Default Messanger.
+//
+// It prints to Stdout.
+func Print(msg string) {
+	Default.Print(msg)
 }
diff --git a/msg/msg_windows.go b/msg/msg_windows.go
deleted file mode 100644
index 7a715f1..0000000
--- a/msg/msg_windows.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// +build windows
-
-package msg
-
-import (
-	"fmt"
-	"strings"
-)
-
-// Info logs information
-func Info(msg string, args ...interface{}) {
-	if Quiet {
-		return
-	}
-	fmt.Print("[INFO] ")
-	Msg(msg, args...)
-}
-
-// Debug logs debug information
-func Debug(msg string, args ...interface{}) {
-	if Quiet || !IsDebugging {
-		return
-	}
-	fmt.Print("[DEBUG] ")
-	Msg(msg, args...)
-}
-
-// Warn logs a warning
-func Warn(msg string, args ...interface{}) {
-	fmt.Fprint(Stderr, "[WARN] ")
-	ErrMsg(msg, args...)
-}
-
-// Error logs and error.
-func Error(msg string, args ...interface{}) {
-	fmt.Fprint(Stderr, "[ERROR] ")
-	ErrMsg(msg, args...)
-}
-
-// ErrMsg sends a message to Stderr
-func ErrMsg(msg string, args ...interface{}) {
-	if len(args) == 0 {
-		fmt.Fprint(Stderr, msg)
-		return
-	}
-	fmt.Fprintf(Stderr, msg, args...)
-}
-
-// Msg prints a message with optional arguments, that can be printed, of
-// varying types.
-func Msg(msg string, args ...interface{}) {
-	if len(args) == 0 {
-		fmt.Print(msg)
-		return
-	}
-	fmt.Printf(msg, args...)
-
-	// Get rid of the annoying fact that messages need \n at the end, but do
-	// it in a backward compatible way.
-	if !strings.HasSuffix(msg, "\n") {
-		fmt.Println("")
-	}
-}
diff --git a/msg/out.go b/msg/out.go
new file mode 100644
index 0000000..8019d21
--- /dev/null
+++ b/msg/out.go
@@ -0,0 +1,28 @@
+// +build !windows
+
+package msg
+
+import "fmt"
+
+// These contanstants map to color codes for shell scripts making them
+// human readable.
+const (
+	Blue   = "0;34"
+	Red    = "0;31"
+	Green  = "0;32"
+	Yellow = "0;33"
+	Cyan   = "0;36"
+	Pink   = "1;35"
+)
+
+// Color returns a string in a certain color. The first argument is a string
+// containing the color code or a constant from the table above mapped to a code.
+//
+// The following will print the string "Foo" in yellow:
+//     fmt.Print(Color(Yellow, "Foo"))
+func (m *Messanger) Color(code, msg string) string {
+	if m.NoColor {
+		return msg
+	}
+	return fmt.Sprintf("\033[%sm%s\033[m", code, msg)
+}
diff --git a/msg/out_windows.go b/msg/out_windows.go
new file mode 100644
index 0000000..fa71e2b
--- /dev/null
+++ b/msg/out_windows.go
@@ -0,0 +1,21 @@
+// +build windows
+
+package msg
+
+// The color codes here are for compatability with how Colors are used. Windows
+// colors have not been implemented yet. See https://github.com/Masterminds/glide/issues/158
+// for more detail.
+const (
+	Blue   = ""
+	Red    = ""
+	Green  = ""
+	Yellow = ""
+	Cyan   = ""
+	Pink   = ""
+)
+
+// Color on windows returns no color. See
+// https://github.com/Masterminds/glide/issues/158 if you want to help.
+func (m *Messanger) Color(code, msg string) string {
+	return msg
+}
diff --git a/msg/vars.go b/msg/vars.go
deleted file mode 100644
index 129b53c..0000000
--- a/msg/vars.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package msg
-
-import (
-	"fmt"
-	"os"
-)
-
-// Quiet, if true, suppresses chatty levels, like Info.
-var Quiet = false
-
-// IsDebugging, if true, shows verbose levels, like Debug.
-var IsDebugging = false
-
-// NoColor, if true, will not use color in the output.
-var NoColor = false
-
-// Stdout is the location where this prints output.
-var Stdout = os.Stdout
-
-// Stderr is the location where this prints logs.
-var Stderr = os.Stderr
-
-// Puts formats a message and then prints to Stdout.
-//
-// It does not prefix the message, does not color it, or otherwise decorate it.
-//
-// It does add a line feed.
-func Puts(msg string, args ...interface{}) {
-	fmt.Fprintf(Stdout, msg, args...)
-	fmt.Fprintln(Stdout)
-}
diff --git a/path/path.go b/path/path.go
new file mode 100644
index 0000000..466cb6d
--- /dev/null
+++ b/path/path.go
@@ -0,0 +1,249 @@
+/* Package path contains path and environment utilities for Glide.
+
+This includes tools to find and manipulate Go path variables, as well as
+tools for copying from one path to another.
+*/
+package action
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const DefaultGlideFile = "glide.yaml"
+
+// VendorDir is the name of the directory that holds vendored dependencies.
+//
+// As of Go 1.5, this is always vendor.
+var VendorDir = "vendor"
+
+// HomeDir is the home directory for Glide.
+//
+// HomeDir is where cache files and other configuration data are stored.
+var HomeDir = "$HOME/.glide"
+
+// GlideFile is the name of the Glide file.
+//
+// Setting this is not concurrency safe. For consistency, it should really
+// only be set once, at startup, or not at all.
+var GlideFile = DefaultGlideFile
+
+const LockFile = "glide.lock"
+
+// Home returns the Glide home directory ($GLIDE_HOME or ~/.glide, typically).
+//
+// This normalizes to an absolute path, and passes through os.ExpandEnv.
+func Home() string {
+	h := os.ExpandEnv(HomeDir)
+	var err error
+	if h, err = filepath.Abs(HomeDir); err != nil {
+		return HomeDir
+	}
+	return h
+}
+
+// VendorPath calculates the path to the vendor directory.
+//
+// Based on working directory, VendorDir and GlideFile, this attempts to
+// guess the location of the vendor directory.
+func Vendor() (string, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+
+	// Find the directory that contains glide.yaml
+	yamldir, err := GlideWD(cwd)
+	if err != nil {
+		return cwd, err
+	}
+
+	gopath := filepath.Join(yamldir, VendorDir)
+
+	return gopath, nil
+}
+
+// Glide gets the path to the closest glide file.
+func Glide() (string, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+
+	// Find the directory that contains glide.yaml
+	yamldir, err := GlideWD(cwd)
+	if err != nil {
+		return cwd, err
+	}
+
+	gf := filepath.Join(yamldir, GlideFile)
+	return gf, nil
+}
+
+// GlideWD finds the working directory of the glide.yaml file, starting at dir.
+//
+// If the glide file is not found in the current directory, it recurses up
+// a directory.
+func GlideWD(dir string) (string, error) {
+	fullpath := filepath.Join(dir, GlideFile)
+
+	if _, err := os.Stat(fullpath); err == nil {
+		return dir, nil
+	}
+
+	base := filepath.Dir(dir)
+	if base == dir {
+		return "", fmt.Errorf("Cannot resolve parent of %s", base)
+	}
+
+	return GlideWD(base)
+}
+
+// Gopath gets GOPATH from environment and return the most relevant path.
+//
+// A GOPATH can contain a colon-separated list of paths. This retrieves the
+// GOPATH and returns only the FIRST ("most relevant") path.
+//
+// This should be used carefully. If, for example, you are looking for a package,
+// you may be better off using Gopaths.
+func Gopath() string {
+	gopaths := Gopaths()
+	if len(gopaths) == 0 {
+		return ""
+	}
+	return gopaths[0]
+}
+
+// Gopaths retrieves the Gopath as a list when there is more than one path
+// listed in the Gopath.
+func Gopaths() []string {
+	p := os.Getenv("GOPATH")
+	p = strings.Trim(p, string(filepath.ListSeparator))
+	return filepath.SplitList(p)
+}
+
+// Basepath returns the current working directory.
+//
+// If there is an error getting the working directory, this returns ".", which
+// should function in cases where the directory is unlinked... Then again,
+// maybe not.
+func Basepath() string {
+	base, err := os.Getwd()
+	if err != nil {
+		return "."
+	}
+	return base
+}
+
+// IsLink returns true if the given FileInfo references a link.
+func IsLink(fi os.FileInfo) bool {
+	return fi.Mode()&os.ModeSymlink == os.ModeSymlink
+}
+
+// HasLock returns true if this can stat a lockfile at the givin location.
+func HasLock(basepath string) bool {
+	_, err := os.Stat(filepath.Join(basepath, LockFile))
+	return err == nil
+}
+
+// IsDirectoryEmpty checks if a directory is empty.
+func IsDirectoryEmpty(dir string) (bool, error) {
+	f, err := os.Open(dir)
+	if err != nil {
+		return false, err
+	}
+	defer f.Close()
+
+	_, err = f.Readdir(1)
+
+	if err == io.EOF {
+		return true, nil
+	}
+
+	return false, err
+}
+
+// CopyDir copies an entire source directory to the dest directory.
+//
+// This is akin to `cp -a src/* dest/`
+//
+// We copy the directory here rather than jumping out to a shell so we can
+// support multiple operating systems.
+func CopyDir(source string, dest string) error {
+
+	// get properties of source dir
+	si, err := os.Stat(source)
+	if err != nil {
+		return err
+	}
+
+	err = os.MkdirAll(dest, si.Mode())
+	if err != nil {
+		return err
+	}
+
+	d, _ := os.Open(source)
+
+	objects, err := d.Readdir(-1)
+
+	for _, obj := range objects {
+
+		sp := filepath.Join(source, "/", obj.Name())
+
+		dp := filepath.Join(dest, "/", obj.Name())
+
+		if obj.IsDir() {
+			err = CopyDir(sp, dp)
+			if err != nil {
+				return err
+			}
+		} else {
+			// perform copy
+			err = CopyFile(sp, dp)
+			if err != nil {
+				return err
+			}
+		}
+
+	}
+	return nil
+}
+
+// CopyFile copies a source file to a destination.
+//
+// It follows symbolic links and retains modes.
+func CopyFile(source string, dest string) error {
+	ln, err := os.Readlink(source)
+	if err == nil {
+		return os.Symlink(ln, dest)
+	}
+	s, err := os.Open(source)
+	if err != nil {
+		return err
+	}
+
+	defer s.Close()
+
+	d, err := os.Create(dest)
+	if err != nil {
+		return err
+	}
+
+	defer d.Close()
+
+	_, err = io.Copy(d, s)
+	if err != nil {
+		return err
+	}
+
+	si, err := os.Stat(source)
+	if err != nil {
+		return err
+	}
+	err = os.Chmod(dest, si.Mode())
+
+	return err
+}
diff --git a/path/path_test.go b/path/path_test.go
new file mode 100644
index 0000000..f2e4447
--- /dev/null
+++ b/path/path_test.go
@@ -0,0 +1,64 @@
+package action
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+const testdata = "../testdata/path"
+
+func TestGlideWD(t *testing.T) {
+	wd := filepath.Join(testdata, "a/b/c")
+	found, err := GlideWD(wd)
+	if err != nil {
+		t.Errorf("Failed to get Glide directory: %s", err)
+	}
+
+	if found != filepath.Join(testdata, "a") {
+		t.Errorf("Expected %s to match %s", found, filepath.Join(wd, "a"))
+	}
+
+	// This should fail
+	wd = "/No/Such/Dir"
+	found, err = GlideWD(wd)
+	if err == nil {
+		t.Errorf("Expected to get an error on a non-existent directory, not %s", found)
+	}
+
+}
+
+func TestVendor(t *testing.T) {
+	td, err := filepath.Abs(testdata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wd, _ := os.Getwd()
+	os.Chdir(filepath.Join(td, "a/b/c"))
+	res, err := Vendor()
+	if err != nil {
+		t.Errorf("Failed to resolve vendor directory: %s", err)
+	}
+	expect := filepath.Join(td, "a", "vendor")
+	if res != expect {
+		t.Errorf("Failed to find vendor: expected %s got %s", expect, res)
+	}
+	os.Chdir(wd)
+}
+func TestGlide(t *testing.T) {
+	wd, _ := os.Getwd()
+	td, err := filepath.Abs(testdata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	os.Chdir(filepath.Join(td, "a/b/c"))
+	res, err := Glide()
+	if err != nil {
+		t.Errorf("Failed to resolve vendor directory: %s", err)
+	}
+	expect := filepath.Join(td, "a", "glide.yaml")
+	if res != expect {
+		t.Errorf("Failed to find vendor: expected %s got %s", expect, res)
+	}
+	os.Chdir(wd)
+}
diff --git a/cmd/cache.go b/repo/cache.go
similarity index 95%
rename from cmd/cache.go
rename to repo/cache.go
index bbb9c7b..43ec644 100644
--- a/cmd/cache.go
+++ b/repo/cache.go
@@ -1,4 +1,4 @@
-package cmd
+package repo
 
 import (
 	"encoding/json"
@@ -10,7 +10,7 @@
 	"strings"
 	"time"
 
-	"github.com/Masterminds/cookoo"
+	//"github.com/Masterminds/glide/msg"
 )
 
 var cacheEnabled = true
@@ -19,11 +19,12 @@
 
 // EnsureCacheDir Creates the $HOME/.glide/cache directory (unless home is
 // specified to be different) if it does not exist.
+/*
 func EnsureCacheDir(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
 	home := p.Get("home", "").(string)
 	if home == "" {
 		cacheEnabled = false
-		Warn("Unable to locate home directory")
+		msg.Warn("Unable to locate home directory")
 		return false, nil
 	}
 	err := os.MkdirAll(filepath.Join(home, "cache", "info"), os.ModeDir|os.ModePerm)
@@ -33,6 +34,7 @@
 	}
 	return false, nil
 }
+*/
 
 // Pass in a repo location and get a cache key from it.
 func cacheCreateKey(repo string) (string, error) {
diff --git a/cmd/cache_test.go b/repo/cache_test.go
similarity index 96%
rename from cmd/cache_test.go
rename to repo/cache_test.go
index 6104434..d5e1c1d 100644
--- a/cmd/cache_test.go
+++ b/repo/cache_test.go
@@ -1,4 +1,4 @@
-package cmd
+package repo
 
 import "testing"
 
diff --git a/repo/installer.go b/repo/installer.go
new file mode 100644
index 0000000..c3db217
--- /dev/null
+++ b/repo/installer.go
@@ -0,0 +1,633 @@
+package repo
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/dependency"
+	"github.com/Masterminds/glide/importer"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/glide/util"
+	"github.com/Masterminds/semver"
+	"github.com/codegangsta/cli"
+)
+
+// Installer provides facilities for installing the repos in a config file.
+type Installer struct {
+
+	// Force the install when certain normally stopping conditions occur.
+	Force bool
+
+	// Home is the location of cache
+	Home string
+
+	// Vendor contains the path to put the vendor packages
+	Vendor string
+
+	// Use a cache
+	UseCache bool
+	// Use Gopath to cache
+	UseCacheGopath bool
+	// Use Gopath as a source to read from
+	UseGopath bool
+
+	// UpdateVendored instructs the environment to update in a way that is friendly
+	// to packages that have been "vendored in" (e.g. are copies of source, not repos)
+	UpdateVendored bool
+
+	// DeleteUnused deletes packages that are unused, but found in the vendor dir.
+	DeleteUnused bool
+
+	// RootPackage is the top level package importing other packages. If an
+	// imported pacakgage references this pacakage it does not need to be
+	// downloaded and searched out again.
+	RootPackage string
+}
+
+// VendorPath returns the path to the location to put vendor packages
+func (i *Installer) VendorPath() string {
+	if i.Vendor != "" {
+		return i.Vendor
+	}
+
+	vp, err := gpath.Vendor()
+	if err != nil {
+		return filepath.FromSlash("./vendor")
+	}
+
+	return vp
+}
+
+// Install installs the dependencies from a Lockfile.
+func (i *Installer) Install(lock *cfg.Lockfile, conf *cfg.Config) (*cfg.Config, error) {
+
+	cwd, err := gpath.Vendor()
+	if err != nil {
+		return conf, err
+	}
+
+	// Create a config setup based on the Lockfile data to process with
+	// existing commands.
+	newConf := &cfg.Config{}
+	newConf.Name = conf.Name
+
+	newConf.Imports = make(cfg.Dependencies, len(lock.Imports))
+	for k, v := range lock.Imports {
+		newConf.Imports[k] = &cfg.Dependency{
+			Name:        v.Name,
+			Reference:   v.Version,
+			Repository:  v.Repository,
+			VcsType:     v.VcsType,
+			Subpackages: v.Subpackages,
+			Arch:        v.Arch,
+			Os:          v.Os,
+		}
+	}
+
+	newConf.DevImports = make(cfg.Dependencies, len(lock.DevImports))
+	for k, v := range lock.DevImports {
+		newConf.DevImports[k] = &cfg.Dependency{
+			Name:        v.Name,
+			Reference:   v.Version,
+			Repository:  v.Repository,
+			VcsType:     v.VcsType,
+			Subpackages: v.Subpackages,
+			Arch:        v.Arch,
+			Os:          v.Os,
+		}
+	}
+
+	newConf.DeDupe()
+
+	if len(newConf.Imports) == 0 {
+		msg.Info("No dependencies found. Nothing installed.\n")
+		return newConf, nil
+	}
+
+	ConcurrentUpdate(newConf.Imports, cwd, i)
+	ConcurrentUpdate(newConf.DevImports, cwd, i)
+	return newConf, nil
+}
+
+// Checkout reads the config file and checks out all dependencies mentioned there.
+//
+// This is used when initializing an empty vendor directory, or when updating a
+// vendor directory based on changed config.
+func (i *Installer) Checkout(conf *cfg.Config, useDev bool) error {
+
+	dest := i.VendorPath()
+
+	if err := ConcurrentUpdate(conf.Imports, dest, i); err != nil {
+		return err
+	}
+
+	if useDev {
+		return ConcurrentUpdate(conf.DevImports, dest, i)
+	}
+
+	return nil
+}
+
+// Update updates all dependencies.
+//
+// It begins with the dependencies in the config file, but also resolves
+// transitive dependencies. The returned lockfile has all of the dependencies
+// listed, but the version reconciliation has not been done.
+//
+// In other words, all versions in the Lockfile will be empty.
+func (i *Installer) Update(conf *cfg.Config) error {
+	base := "."
+	vpath := i.VendorPath()
+
+	ic := newImportCache()
+
+	m := &MissingPackageHandler{
+		destination: vpath,
+
+		cache:       i.UseCache,
+		cacheGopath: i.UseCacheGopath,
+		useGopath:   i.UseGopath,
+		home:        i.Home,
+		Config:      conf,
+		Use:         ic,
+	}
+
+	v := &VersionHandler{
+		Destination: vpath,
+		Use:         ic,
+		Imported:    make(map[string]bool),
+		Conflicts:   make(map[string]bool),
+		Config:      conf,
+	}
+
+	// Update imports
+	res, err := dependency.NewResolver(base)
+	if err != nil {
+		msg.Die("Failed to create a resolver: %s", err)
+	}
+	res.Config = conf
+	res.Handler = m
+	res.VersionHandler = v
+	msg.Info("Resolving imports")
+	_, err = allPackages(conf.Imports, res)
+	if err != nil {
+		msg.Die("Failed to retrieve a list of dependencies: %s", err)
+	}
+
+	msg.Warn("devImports not resolved.")
+
+	err = ConcurrentUpdate(conf.Imports, vpath, i)
+
+	return err
+}
+
+func (i *Installer) List(conf *cfg.Config) []*cfg.Dependency {
+	base := "."
+	vpath := i.VendorPath()
+
+	ic := newImportCache()
+
+	v := &VersionHandler{
+		Destination: vpath,
+		Use:         ic,
+		Imported:    make(map[string]bool),
+		Conflicts:   make(map[string]bool),
+		Config:      conf,
+	}
+
+	// Update imports
+	res, err := dependency.NewResolver(base)
+	if err != nil {
+		msg.Die("Failed to create a resolver: %s", err)
+	}
+	res.Config = conf
+	res.VersionHandler = v
+
+	msg.Info("Resolving imports")
+	_, err = allPackages(conf.Imports, res)
+	if err != nil {
+		msg.Die("Failed to retrieve a list of dependencies: %s", err)
+	}
+
+	msg.Warn("devImports not resolved.")
+
+	return conf.Imports
+}
+
+// ConcurrentUpdate takes a list of dependencies and updates in parallel.
+func ConcurrentUpdate(deps []*cfg.Dependency, cwd string, i *Installer) error {
+	done := make(chan struct{}, concurrentWorkers)
+	in := make(chan *cfg.Dependency, concurrentWorkers)
+	var wg sync.WaitGroup
+	var lock sync.Mutex
+	var returnErr error
+
+	for ii := 0; ii < concurrentWorkers; ii++ {
+		go func(ch <-chan *cfg.Dependency) {
+			for {
+				select {
+				case dep := <-ch:
+					if err := VcsUpdate(dep, cwd, i); err != nil {
+						msg.Warn("Update failed for %s: %s\n", dep.Name, err)
+						// Capture the error while making sure the concurrent
+						// operations don't step on each other.
+						lock.Lock()
+						if returnErr == nil {
+							returnErr = err
+						} else {
+							returnErr = cli.NewMultiError(returnErr, err)
+						}
+						lock.Unlock()
+					}
+					wg.Done()
+				case <-done:
+					return
+				}
+			}
+		}(in)
+	}
+
+	for _, dep := range deps {
+		wg.Add(1)
+		in <- dep
+	}
+
+	wg.Wait()
+
+	// Close goroutines setting the version
+	for ii := 0; ii < concurrentWorkers; ii++ {
+		done <- struct{}{}
+	}
+
+	return returnErr
+}
+
+// allPackages gets a list of all packages required to satisfy the given deps.
+func allPackages(deps []*cfg.Dependency, res *dependency.Resolver) ([]string, error) {
+	if len(deps) == 0 {
+		return []string{}, nil
+	}
+
+	vdir, err := gpath.Vendor()
+	if err != nil {
+		return []string{}, err
+	}
+	vdir += string(os.PathSeparator)
+	ll, err := res.ResolveAll(deps)
+	if err != nil {
+		return []string{}, err
+	}
+
+	for i := 0; i < len(ll); i++ {
+		ll[i] = strings.TrimPrefix(ll[i], vdir)
+	}
+	return ll, nil
+}
+
+// MissingPackageHandler is a dependency.MissingPackageHandler.
+//
+// When a package is not found, this attempts to resolve and fetch.
+//
+// When a package is found on the GOPATH, this notifies the user.
+type MissingPackageHandler struct {
+	destination                   string
+	home                          string
+	cache, cacheGopath, useGopath bool
+	RootPackage                   string
+	Config                        *cfg.Config
+	Use                           *importCache
+}
+
+func (m *MissingPackageHandler) NotFound(pkg string) (bool, error) {
+	root := util.GetRootFromPackage(pkg)
+
+	// Skip any references to the root package.
+	if root == m.RootPackage {
+		return false, nil
+	}
+
+	dest := filepath.Join(m.destination, root)
+
+	// This package may have been placed on the list to look for when it wasn't
+	// downloaded but it has since been downloaded before coming to this entry.
+	if _, err := os.Stat(dest); err == nil {
+		return true, nil
+	}
+
+	msg.Info("Fetching %s into %s", pkg, m.destination)
+
+	d := m.Config.Imports.Get(root)
+	// If the dependency is nil it means the Config doesn't yet know about it.
+	if d == nil {
+		d = m.Use.Get(root)
+		// We don't know about this dependency so we create a basic instance.
+		if d == nil {
+			d = &cfg.Dependency{Name: root}
+		}
+
+		m.Config.Imports = append(m.Config.Imports, d)
+	}
+	if err := VcsGet(d, dest, m.home, m.cache, m.cacheGopath, m.useGopath); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (m *MissingPackageHandler) OnGopath(pkg string) (bool, error) {
+	// If useGopath is false, we fall back to the strategy of fetching from
+	// remote.
+	if !m.useGopath {
+		return m.NotFound(pkg)
+	}
+
+	root := util.GetRootFromPackage(pkg)
+
+	// Skip any references to the root package.
+	if root == m.RootPackage {
+		return false, nil
+	}
+
+	msg.Info("Copying package %s from the GOPATH.", pkg)
+	dest := filepath.Join(m.destination, pkg)
+	// Find package on Gopath
+	for _, gp := range gpath.Gopaths() {
+		src := filepath.Join(gp, pkg)
+		// FIXME: Should probably check if src is a dir or symlink.
+		if _, err := os.Stat(src); err == nil {
+			if err := os.MkdirAll(dest, os.ModeDir|0755); err != nil {
+				return false, err
+			}
+			if err := gpath.CopyDir(src, dest); err != nil {
+				return false, err
+			}
+			return true, nil
+		}
+	}
+
+	msg.Error("Could not locate %s on the GOPATH, though it was found before.", pkg)
+	return false, nil
+}
+
+// VersionHandler handles setting the proper version in the VCS.
+type VersionHandler struct {
+
+	// If Try to use the version here if we have one. This is a cache and will
+	// change over the course of setting versions.
+	Use *importCache
+
+	// Cache if importing scan has already occured here.
+	Imported map[string]bool
+
+	// Where the packages exist to set the version on.
+	Destination string
+
+	RootPackage string
+	Config      *cfg.Config
+
+	// There's a problem where many sub-packages have been asked to set a version
+	// and you can end up with numerous conflict messages that are exactly the
+	// same. We are keeping track to only display them once.
+	// the parent pac
+	Conflicts map[string]bool
+}
+
+// Process imports dependencies for a package
+func (d *VersionHandler) Process(pkg string) (e error) {
+	root := util.GetRootFromPackage(pkg)
+
+	// Skip any references to the root package.
+	if root == d.RootPackage {
+		return nil
+	}
+
+	// We have not tried to import, yet.
+	// Should we look in places other than the root of the project?
+	if d.Imported[root] == false {
+		d.Imported[root] = true
+		p := filepath.Join(d.Destination, root)
+		f, deps, err := importer.Import(p)
+		if f && err == nil {
+			for _, dep := range deps {
+
+				// The fist one wins. Would something smater than this be better?
+				exists := d.Use.Get(dep.Name)
+				if exists == nil && (dep.Reference != "" || dep.Repository != "") {
+					d.Use.Add(dep.Name, dep)
+				}
+			}
+		} else if err != nil {
+			msg.Error("Unable to import from %s. Err: %s", root, err)
+			e = err
+		}
+	}
+
+	return
+}
+
+// SetVersion sets the version for a package. If that package version is already
+// set it handles the case by:
+// - keeping the already set version
+// - proviting messaging about the version conflict
+// TODO(mattfarina): The way version setting happens can be improved. Currently not optimal.
+func (d *VersionHandler) SetVersion(pkg string) (e error) {
+	root := util.GetRootFromPackage(pkg)
+
+	// Skip any references to the root package.
+	if root == d.RootPackage {
+		return nil
+	}
+
+	v := d.Config.Imports.Get(root)
+
+	dep := d.Use.Get(root)
+	if dep != nil && v != nil {
+		if v.Reference == "" && dep.Reference != "" {
+			v.Reference = dep.Reference
+			// Clear the pin, if set, so the new version can be used.
+			v.Pin = ""
+			dep = v
+		} else if v.Reference != "" && dep.Reference != "" && v.Reference != dep.Reference {
+			dest := filepath.Join(d.Destination, filepath.FromSlash(v.Name))
+			dep = determineDependency(v, dep, dest)
+		}
+
+	} else if dep != nil {
+		// We've got an imported dependency to use and don't already have a
+		// record of it. Append it to the Imports.
+		d.Config.Imports = append(d.Config.Imports, dep)
+	} else if v != nil {
+		dep = v
+	} else {
+		// If we've gotten here we don't have any depenency objects.
+		r, sp := util.NormalizeName(pkg)
+		dep = &cfg.Dependency{
+			Name: r,
+		}
+		if sp != "" {
+			dep.Subpackages = []string{sp}
+		}
+		d.Config.Imports = append(d.Config.Imports, dep)
+	}
+
+	err := VcsVersion(dep, d.Destination)
+	if err != nil {
+		msg.Warn("Unable to set verion on %s to %s. Err: %s", root, dep.Reference, err)
+		e = err
+	}
+
+	return
+}
+
+func determineDependency(v, dep *cfg.Dependency, dest string) *cfg.Dependency {
+	repo, err := v.GetRepo(dest)
+	if err != nil {
+		singleWarn("Unable to access repo for %s\n", v.Name)
+		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		return v
+	}
+
+	vIsRef := repo.IsReference(v.Reference)
+	depIsRef := repo.IsReference(dep.Reference)
+
+	// Both are references and they are different ones.
+	if vIsRef && depIsRef {
+		singleWarn("Conflict: %s ref is %s, but also asked for %s\n", v.Name, v.Reference, dep.Reference)
+		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		return v
+	} else if vIsRef {
+		// The current one is a reference and the suggestion is a SemVer constraint.
+		con, err := semver.NewConstraint(dep.Reference)
+		if err != nil {
+			singleWarn("Version issue for %s: '%s' is neither a reference or semantic version constraint\n", dep.Name, dep.Reference)
+			singleInfo("Keeping %s %s", v.Name, v.Reference)
+			return v
+		}
+
+		ver, err := semver.NewVersion(v.Reference)
+		if err != nil {
+			// The existing version is not a semantic version.
+			singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Reference, dep.Reference)
+			singleInfo("Keeping %s %s", v.Name, v.Reference)
+			return v
+		}
+
+		if con.Check(ver) {
+			singleInfo("Keeping %s %s because it fits constraint '%s'", v.Name, v.Reference, dep.Reference)
+			return v
+		}
+		singleWarn("Conflict: %s version is %s but does not meet constraint '%s'\n", v.Name, v.Reference, dep.Reference)
+		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		return v
+	} else if depIsRef {
+
+		con, err := semver.NewConstraint(v.Reference)
+		if err != nil {
+			singleWarn("Version issue for %s: '%s' is neither a reference or semantic version constraint\n", v.Name, v.Reference)
+			singleInfo("Keeping %s %s", v.Name, v.Reference)
+			return v
+		}
+
+		ver, err := semver.NewVersion(dep.Reference)
+		if err != nil {
+			singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Reference, dep.Reference)
+			singleInfo("Keeping %s %s", v.Name, v.Reference)
+			return v
+		}
+
+		if con.Check(ver) {
+			v.Reference = dep.Reference
+			singleInfo("Using %s %s because it fits constraint '%s'", v.Name, v.Reference, v.Reference)
+			return v
+		}
+		singleWarn("Conflict: %s semantic version constraint is %s but '%s' does not meet the constraint\n", v.Name, v.Reference, v.Reference)
+		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		return v
+	}
+	// Neither is a vcs reference and both could be semantic version
+	// constraints that are different.
+
+	_, err = semver.NewConstraint(dep.Reference)
+	if err != nil {
+		// dd.Reference is not a reference or a valid constraint.
+		singleWarn("Version %s %s is not a reference or valid semantic version constraint\n", dep.Name, dep.Reference)
+		singleInfo("Keeping %s %s", v.Name, v.Reference)
+		return v
+	}
+
+	_, err = semver.NewConstraint(v.Reference)
+	if err != nil {
+		// existing.Reference is not a reference or a valid constraint.
+		// We really should never end up here.
+		singleWarn("Version %s %s is not a reference or valid semantic version constraint\n", v.Name, v.Reference)
+
+		v.Reference = dep.Reference
+		v.Pin = ""
+		singleInfo("Using %s %s because it is a valid version", v.Name, v.Reference)
+		return v
+	}
+
+	// Both versions are constraints. Try to merge them.
+	// If either comparison has an || skip merging. That's complicated.
+	ddor := strings.Index(dep.Reference, "||")
+	eor := strings.Index(v.Reference, "||")
+	if ddor == -1 && eor == -1 {
+		// Add the comparisons together.
+		newRef := v.Reference + ", " + dep.Reference
+		v.Reference = newRef
+		v.Pin = ""
+		singleInfo("Combining %s semantic version constraints %s and %s", v.Name, v.Reference, dep.Reference)
+		return v
+	}
+	singleWarn("Conflict: %s version is %s, but also asked for %s\n", v.Name, v.Reference, dep.Reference)
+	singleInfo("Keeping %s %s", v.Name, v.Reference)
+	return v
+}
+
+var warningMessage = make(map[string]bool)
+var infoMessage = make(map[string]bool)
+
+func singleWarn(ft string, v ...interface{}) {
+	m := fmt.Sprintf(ft, v...)
+	_, f := warningMessage[m]
+	if !f {
+		msg.Warn(m)
+		warningMessage[m] = true
+	}
+}
+
+func singleInfo(ft string, v ...interface{}) {
+	m := fmt.Sprintf(ft, v...)
+	_, f := infoMessage[m]
+	if !f {
+		msg.Info(m)
+		infoMessage[m] = true
+	}
+}
+
+type importCache struct {
+	cache map[string]*cfg.Dependency
+}
+
+func newImportCache() *importCache {
+	return &importCache{
+		cache: make(map[string]*cfg.Dependency),
+	}
+}
+
+func (i *importCache) Get(name string) *cfg.Dependency {
+	d, f := i.cache[name]
+	if f {
+		return d
+	}
+
+	return nil
+}
+
+func (i *importCache) Add(name string, dep *cfg.Dependency) {
+	i.cache[name] = dep
+}
diff --git a/repo/repo.go b/repo/repo.go
new file mode 100644
index 0000000..3270f5c
--- /dev/null
+++ b/repo/repo.go
@@ -0,0 +1,17 @@
+/* package Repo provides tools for working with VCS repositories.
+
+Glide manages repositories in the vendor directory by using the native VCS
+systems of each repository upon which the code relies.
+*/
+package repo
+
+// concurrentWorkers is the number of workers to be used in concurrent operations.
+var concurrentWorkers = 20
+
+// UpdatingVendored indicates whether this run of Glide is updating a vendored vendor/ path.
+//
+// It is related to the --update-vendor flag for update and install.
+//
+// TODO: This is legacy, and maybe we should handle it differently. It should
+// be set either 0 or 1 times, and only at startup.
+//var UpdatingVendored bool = false
diff --git a/cmd/semver.go b/repo/semver.go
similarity index 74%
rename from cmd/semver.go
rename to repo/semver.go
index 566f431..e200a2c 100644
--- a/cmd/semver.go
+++ b/repo/semver.go
@@ -1,4 +1,4 @@
-package cmd
+package repo
 
 import (
 	"github.com/Masterminds/semver"
@@ -33,16 +33,3 @@
 
 	return append(branches, tags...), nil
 }
-
-func isBranch(branch string, repo vcs.Repo) (bool, error) {
-	branches, err := repo.Branches()
-	if err != nil {
-		return false, err
-	}
-	for _, b := range branches {
-		if b == branch {
-			return true, nil
-		}
-	}
-	return false, nil
-}
diff --git a/repo/set_reference.go b/repo/set_reference.go
new file mode 100644
index 0000000..d40615b
--- /dev/null
+++ b/repo/set_reference.go
@@ -0,0 +1,59 @@
+package repo
+
+import (
+	"sync"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+)
+
+// SetReference is a command to set the VCS reference (commit id, tag, etc) for
+// a project.
+func SetReference(conf *cfg.Config) error {
+
+	cwd, err := gpath.Vendor()
+	if err != nil {
+		return err
+	}
+
+	if len(conf.Imports) == 0 {
+		msg.Info("No references set.\n")
+		return nil
+	}
+
+	done := make(chan struct{}, concurrentWorkers)
+	in := make(chan *cfg.Dependency, concurrentWorkers)
+	var wg sync.WaitGroup
+
+	for i := 0; i < concurrentWorkers; i++ {
+		go func(ch <-chan *cfg.Dependency) {
+			for {
+				select {
+				case dep := <-ch:
+					if err := VcsVersion(dep, cwd); err != nil {
+						msg.Warn("Failed to set version on %s to %s: %s\n", dep.Name, dep.Reference, err)
+					}
+					wg.Done()
+				case <-done:
+					return
+				}
+			}
+		}(in)
+	}
+
+	for _, dep := range conf.Imports {
+		wg.Add(1)
+		in <- dep
+	}
+
+	wg.Wait()
+	// Close goroutines setting the version
+	for i := 0; i < concurrentWorkers; i++ {
+		done <- struct{}{}
+	}
+	// close(done)
+	// close(in)
+
+	return nil
+}
diff --git a/repo/vcs.go b/repo/vcs.go
new file mode 100644
index 0000000..d463b22
--- /dev/null
+++ b/repo/vcs.go
@@ -0,0 +1,662 @@
+package repo
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/semver"
+	v "github.com/Masterminds/vcs"
+)
+
+// VcsUpdate updates to a particular checkout based on the VCS setting.
+func VcsUpdate(dep *cfg.Dependency, vend string, inst *Installer) error {
+
+	// If the dependency has already been pinned we can skip it. This is a
+	// faster path so we don't need to resolve it again.
+	if dep.Pin != "" {
+		msg.Debug("Dependency %s has already been pinned. Fetching updates skipped.", dep.Name)
+		return nil
+	}
+
+	msg.Info("Fetching updates for %s.\n", dep.Name)
+
+	if filterArchOs(dep) {
+		msg.Info("%s is not used for %s/%s.\n", dep.Name, runtime.GOOS, runtime.GOARCH)
+		return nil
+	}
+
+	dest := filepath.Join(vend, dep.Name)
+	// If destination doesn't exist we need to perform an initial checkout.
+	if _, err := os.Stat(dest); os.IsNotExist(err) {
+		if err = VcsGet(dep, dest, inst.Home, inst.UseCache, inst.UseCacheGopath, inst.UseGopath); err != nil {
+			msg.Warn("Unable to checkout %s\n", dep.Name)
+			return err
+		}
+	} else {
+		// At this point we have a directory for the package.
+
+		// When the directory is not empty and has no VCS directory it's
+		// a vendored files situation.
+		empty, err := gpath.IsDirectoryEmpty(dest)
+		if err != nil {
+			return err
+		}
+		_, err = v.DetectVcsFromFS(dest)
+		if inst.UpdateVendored == false && empty == false && err == v.ErrCannotDetectVCS {
+			msg.Warn("%s appears to be a vendored package. Unable to update. Consider the '--update-vendored' flag.\n", dep.Name)
+		} else {
+
+			if inst.UpdateVendored == true && empty == false && err == v.ErrCannotDetectVCS {
+				// A vendored package, no repo, and updating the vendored packages
+				// has been opted into.
+				msg.Info("%s is a vendored package. Updating.", dep.Name)
+				err = os.RemoveAll(dest)
+				if err != nil {
+					msg.Error("Unable to update vendored dependency %s.\n", dep.Name)
+					return err
+				} else {
+					dep.UpdateAsVendored = true
+				}
+
+				if err = VcsGet(dep, dest, inst.Home, inst.UseCache, inst.UseCacheGopath, inst.UseGopath); err != nil {
+					msg.Warn("Unable to checkout %s\n", dep.Name)
+					return err
+				}
+
+				return nil
+			}
+
+			repo, err := dep.GetRepo(dest)
+
+			// Tried to checkout a repo to a path that does not work. Either the
+			// type or endpoint has changed. Force is being passed in so the old
+			// location can be removed and replaced with the new one.
+			// Warning, any changes in the old location will be deleted.
+			// TODO: Put dirty checking in on the existing local checkout.
+			if (err == v.ErrWrongVCS || err == v.ErrWrongRemote) && inst.Force == true {
+				var newRemote string
+				if len(dep.Repository) > 0 {
+					newRemote = dep.Repository
+				} else {
+					newRemote = "https://" + dep.Name
+				}
+
+				msg.Warn("Replacing %s with contents from %s\n", dep.Name, newRemote)
+				rerr := os.RemoveAll(dest)
+				if rerr != nil {
+					return rerr
+				}
+				if err = VcsGet(dep, dest, inst.Home, inst.UseCache, inst.UseCacheGopath, inst.UseGopath); err != nil {
+					msg.Warn("Unable to checkout %s\n", dep.Name)
+					return err
+				}
+			} else if err != nil {
+				return err
+			} else if repo.IsDirty() {
+				return fmt.Errorf("%s contains uncommited changes. Skipping update", dep.Name)
+			} else {
+
+				// Check if the current version is a tag or commit id. If it is
+				// and that version is already checked out we can skip updating
+				// which is faster than going out to the Internet to perform
+				// an update.
+				if dep.Reference != "" {
+					version, err := repo.Version()
+					if err != nil {
+						return err
+					}
+					ib, err := isBranch(dep.Reference, repo)
+					if err != nil {
+						return err
+					}
+
+					// If the current version equals the ref and it's not a
+					// branch it's a tag or commit id so we can skip
+					// performing an update.
+					if version == dep.Reference && !ib {
+						msg.Info("%s is already set to version %s. Skipping update.", dep.Name, dep.Reference)
+						return nil
+					}
+				}
+
+				if err := repo.Update(); err != nil {
+					msg.Warn("Download failed.\n")
+					return err
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// VcsVersion set the VCS version for a checkout.
+func VcsVersion(dep *cfg.Dependency, vend string) error {
+
+	// If the dependency has already been pinned we can skip it. This is a
+	// faster path so we don't need to resolve it again.
+	if dep.Pin != "" {
+		msg.Debug("Dependency %s has already been pinned. Setting version skipped.", dep.Name)
+		return nil
+	}
+
+	cwd := filepath.Join(vend, dep.Name)
+
+	// If there is no refernece configured there is nothing to set.
+	if dep.Reference == "" {
+		// Before exiting update the pinned version
+		repo, err := dep.GetRepo(cwd)
+		if err != nil {
+			return err
+		}
+		dep.Pin, err = repo.Version()
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+
+	// When the directory is not empty and has no VCS directory it's
+	// a vendored files situation.
+	empty, err := gpath.IsDirectoryEmpty(cwd)
+	if err != nil {
+		return err
+	}
+	_, err = v.DetectVcsFromFS(cwd)
+	if empty == false && err == v.ErrCannotDetectVCS {
+		msg.Warn("%s appears to be a vendored package. Unable to set new version. Consider the '--update-vendored' flag.\n", dep.Name)
+	} else {
+		repo, err := dep.GetRepo(cwd)
+		if err != nil {
+			return err
+		}
+
+		ver := dep.Reference
+		// Referenes in Git can begin with a ^ which is similar to semver.
+		// If there is a ^ prefix we assume it's a semver constraint rather than
+		// part of the git/VCS commit id.
+		if repo.IsReference(ver) && !strings.HasPrefix(ver, "^") {
+			msg.Info("Setting version for %s to %s.\n", dep.Name, ver)
+		} else {
+
+			// Create the constraing first to make sure it's valid before
+			// working on the repo.
+			constraint, err := semver.NewConstraint(ver)
+
+			// Make sure the constriant is valid. At this point it's not a valid
+			// reference so if it's not a valid constrint we can exit early.
+			if err != nil {
+				msg.Warn("The reference '%s' is not valid\n", ver)
+				return err
+			}
+
+			// Get the tags and branches (in that order)
+			refs, err := getAllVcsRefs(repo)
+			if err != nil {
+				return err
+			}
+
+			// Convert and filter the list to semver.Version instances
+			semvers := getSemVers(refs)
+
+			// Sort semver list
+			sort.Sort(sort.Reverse(semver.Collection(semvers)))
+			found := false
+			for _, v := range semvers {
+				if constraint.Check(v) {
+					found = true
+					// If the constrint passes get the original reference
+					ver = v.Original()
+					break
+				}
+			}
+			if found {
+				msg.Info("Detected semantic version. Setting version for %s to %s.\n", dep.Name, ver)
+			} else {
+				msg.Warn("Unable to find semantic version for constraint %s %s\n", dep.Name, ver)
+			}
+		}
+		if err := repo.UpdateVersion(ver); err != nil {
+			msg.Error("Failed to set version to %s: %s\n", dep.Reference, err)
+			return err
+		}
+		dep.Pin, err = repo.Version()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// VcsGet figures out how to fetch a dependency, and then gets it.
+//
+// VcsGet installs into the dest.
+func VcsGet(dep *cfg.Dependency, dest, home string, cache, cacheGopath, useGopath bool) error {
+	// When not skipping the $GOPATH look in it for a copy of the package
+	if useGopath {
+		// Check if the $GOPATH has a viable version to use and if so copy to vendor
+		gps := gpath.Gopaths()
+		for _, p := range gps {
+			d := filepath.Join(p, "src", dep.Name)
+			if _, err := os.Stat(d); err == nil {
+				empty, err := gpath.IsDirectoryEmpty(d)
+				if empty || err != nil {
+					continue
+				}
+
+				repo, err := dep.GetRepo(d)
+				if err != nil {
+					continue
+				}
+
+				// Dirty repos have uncomitted changes.
+				if repo.IsDirty() {
+					continue
+				}
+
+				// Having found a repo we copy it to vendor and update it.
+				msg.Debug("Found %s in GOPATH at %s. Copying to %s", dep.Name, d, dest)
+				err = gpath.CopyDir(d, dest)
+				if err != nil {
+					return err
+				}
+
+				// Update the repo in the vendor directory
+				msg.Debug("Updating %s, now in the vendor path at %s", dep.Name, dest)
+				repo, err = dep.GetRepo(dest)
+				if err != nil {
+					return err
+				}
+				err = repo.Update()
+				if err != nil {
+					return err
+				}
+
+				// If there is no reference set on the dep we try to checkout
+				// the default branch.
+				if dep.Reference == "" {
+					db := defaultBranch(repo, home)
+					if db != "" {
+						err = repo.UpdateVersion(db)
+						if err != nil && msg.Default.IsDebugging {
+							msg.Debug("Attempting to set the version on %s to %s failed. Error %s", dep.Name, db, err)
+						}
+					}
+				}
+				return nil
+			}
+		}
+	}
+
+	// When opting in to cache in the GOPATH attempt to do put a copy there.
+	if cacheGopath {
+
+		// Since we didn't find an existing copy in the GOPATHs try to clone there.
+		gp := gpath.Gopath()
+		if gp != "" {
+			d := filepath.Join(gp, "src", dep.Name)
+			if _, err := os.Stat(d); os.IsNotExist(err) {
+				// Empty directory so we checkout out the code here.
+				msg.Debug("Retrieving %s to %s before copying to vendor", dep.Name, d)
+				repo, err := dep.GetRepo(d)
+				if err != nil {
+					return err
+				}
+				repo.Get()
+
+				branch := findCurrentBranch(repo)
+				if branch != "" {
+					// we know the default branch so we can store it in the cache
+					var loc string
+					if dep.Repository != "" {
+						loc = dep.Repository
+					} else {
+						loc = "https://" + dep.Name
+					}
+					key, err := cacheCreateKey(loc)
+					if err == nil {
+						msg.Debug("Saving default branch for %s", repo.Remote())
+						c := cacheRepoInfo{DefaultBranch: branch}
+						err = saveCacheRepoData(key, c, home)
+						if msg.Default.IsDebugging && err == errCacheDisabled {
+							msg.Debug("Unable to cache default branch because caching is disabled")
+						}
+					}
+				}
+
+				msg.Debug("Copying %s from GOPATH at %s to %s", dep.Name, d, dest)
+				err = gpath.CopyDir(d, dest)
+				if err != nil {
+					return err
+				}
+
+				return nil
+			}
+		}
+	}
+
+	// If opting in to caching attempt to put it in the cache folder
+	if cache {
+		// Check if the cache has a viable version and try to use that.
+		var loc string
+		if dep.Repository != "" {
+			loc = dep.Repository
+		} else {
+			loc = "https://" + dep.Name
+		}
+		key, err := cacheCreateKey(loc)
+		if err == nil {
+			d := filepath.Join(home, "cache", "src", key)
+
+			repo, err := dep.GetRepo(d)
+			if err != nil {
+				return err
+			}
+			// If the directory does not exist this is a first cache.
+			if _, err = os.Stat(d); os.IsNotExist(err) {
+				msg.Debug("Adding %s to the cache for the first time", dep.Name)
+				err = repo.Get()
+				if err != nil {
+					return err
+				}
+				branch := findCurrentBranch(repo)
+				if branch != "" {
+					// we know the default branch so we can store it in the cache
+					var loc string
+					if dep.Repository != "" {
+						loc = dep.Repository
+					} else {
+						loc = "https://" + dep.Name
+					}
+					key, err := cacheCreateKey(loc)
+					if err == nil {
+						msg.Debug("Saving default branch for %s", repo.Remote())
+						c := cacheRepoInfo{DefaultBranch: branch}
+						err = saveCacheRepoData(key, c, home)
+						if err == errCacheDisabled {
+							msg.Debug("Unable to cache default branch because caching is disabled")
+						} else if err != nil {
+							msg.Debug("Error saving %s to cache. Error: %s", repo.Remote(), err)
+						}
+					}
+				}
+
+			} else {
+				msg.Debug("Updating %s in the cache", dep.Name)
+				err = repo.Update()
+				if err != nil {
+					return err
+				}
+			}
+
+			msg.Debug("Copying %s from the cache to %s", dep.Name, dest)
+			err = gpath.CopyDir(d, dest)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		} else {
+			msg.Warn("Cache key generation error: %s", err)
+		}
+	}
+
+	// If unable to cache pull directly into the vendor/ directory.
+	repo, err := dep.GetRepo(dest)
+	if err != nil {
+		return err
+	}
+
+	gerr := repo.Get()
+
+	// Attempt to cache the default branch
+	branch := findCurrentBranch(repo)
+	if branch != "" {
+		// we know the default branch so we can store it in the cache
+		var loc string
+		if dep.Repository != "" {
+			loc = dep.Repository
+		} else {
+			loc = "https://" + dep.Name
+		}
+		key, err := cacheCreateKey(loc)
+		if err == nil {
+			msg.Debug("Saving default branch for %s", repo.Remote())
+			c := cacheRepoInfo{DefaultBranch: branch}
+			err = saveCacheRepoData(key, c, home)
+			if err == errCacheDisabled {
+				msg.Debug("Unable to cache default branch because caching is disabled")
+			} else if err != nil {
+				msg.Debug("Error saving %s to cache - Error: %s", repo.Remote(), err)
+			}
+		}
+	}
+
+	return gerr
+}
+
+// filterArchOs indicates a dependency should be filtered out because it is
+// the wrong GOOS or GOARCH.
+//
+// FIXME: Should this be moved to the dependency package?
+func filterArchOs(dep *cfg.Dependency) bool {
+	found := false
+	if len(dep.Arch) > 0 {
+		for _, a := range dep.Arch {
+			if a == runtime.GOARCH {
+				found = true
+			}
+		}
+		// If it's not found, it should be filtered out.
+		if !found {
+			return true
+		}
+	}
+
+	found = false
+	if len(dep.Os) > 0 {
+		for _, o := range dep.Os {
+			if o == runtime.GOOS {
+				found = true
+			}
+		}
+		if !found {
+			return true
+		}
+
+	}
+
+	return false
+}
+
+// isBranch returns true if the given string is a branch in VCS.
+func isBranch(branch string, repo v.Repo) (bool, error) {
+	branches, err := repo.Branches()
+	if err != nil {
+		return false, err
+	}
+	for _, b := range branches {
+		if b == branch {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// defaultBranch tries to ascertain the default branch for the given repo.
+// Some repos will have multiple branches in them (e.g. Git) while others
+// (e.g. Svn) will not.
+func defaultBranch(repo v.Repo, home string) string {
+
+	// Svn and Bzr use different locations (paths or entire locations)
+	// for branches so we won't have a default branch.
+	if repo.Vcs() == v.Svn || repo.Vcs() == v.Bzr {
+		return ""
+	}
+
+	// Check the cache for a value.
+	key, kerr := cacheCreateKey(repo.Remote())
+	var d cacheRepoInfo
+	if kerr == nil {
+		d, err := cacheRepoData(key, home)
+		if err == nil {
+			if d.DefaultBranch != "" {
+				return d.DefaultBranch
+			}
+		}
+	}
+
+	// If we don't have it in the store try some APIs
+	r := repo.Remote()
+	u, err := url.Parse(r)
+	if err != nil {
+		return ""
+	}
+	if u.Scheme == "" {
+		// Where there is no scheme we try urls like git@github.com:foo/bar
+		r = strings.Replace(r, ":", "/", -1)
+		r = "ssh://" + r
+		u, err = url.Parse(r)
+		if err != nil {
+			return ""
+		}
+		u.Scheme = ""
+	}
+	if u.Host == "github.com" {
+		parts := strings.Split(u.Path, "/")
+		if len(parts) != 2 {
+			return ""
+		}
+		api := fmt.Sprintf("https://api.github.com/repos/%s/%s", parts[0], parts[1])
+		resp, err := http.Get(api)
+		if err != nil {
+			return ""
+		}
+		defer resp.Body.Close()
+		if resp.StatusCode >= 300 || resp.StatusCode < 200 {
+			return ""
+		}
+		body, err := ioutil.ReadAll(resp.Body)
+		var data interface{}
+		err = json.Unmarshal(body, &data)
+		if err != nil {
+			return ""
+		}
+		gh := data.(map[string]interface{})
+		db := gh["default_branch"].(string)
+		if kerr == nil {
+			d.DefaultBranch = db
+			err := saveCacheRepoData(key, d, home)
+			if err == errCacheDisabled {
+				msg.Debug("Unable to cache default branch because caching is disabled")
+			} else if err != nil {
+				msg.Debug("Error saving %s to cache. Error: %s", repo.Remote(), err)
+			}
+		}
+		return db
+	}
+
+	if u.Host == "bitbucket.org" {
+		parts := strings.Split(u.Path, "/")
+		if len(parts) != 2 {
+			return ""
+		}
+		api := fmt.Sprintf("https://bitbucket.org/api/1.0/repositories/%s/%s/main-branch/", parts[0], parts[1])
+		resp, err := http.Get(api)
+		if err != nil {
+			return ""
+		}
+		defer resp.Body.Close()
+		if resp.StatusCode >= 300 || resp.StatusCode < 200 {
+			return ""
+		}
+		body, err := ioutil.ReadAll(resp.Body)
+		var data interface{}
+		err = json.Unmarshal(body, &data)
+		if err != nil {
+			return ""
+		}
+		bb := data.(map[string]interface{})
+		db := bb["name"].(string)
+		if kerr == nil {
+			d.DefaultBranch = db
+			err := saveCacheRepoData(key, d, home)
+			if err == errCacheDisabled {
+				msg.Debug("Unable to cache default branch because caching is disabled")
+			} else if err != nil {
+				msg.Debug("Error saving %s to cache. Error: %s", repo.Remote(), err)
+			}
+		}
+		return db
+	}
+
+	return ""
+}
+
+// From a local repo find out the current branch name if there is one.
+func findCurrentBranch(repo v.Repo) string {
+	msg.Debug("Attempting to find current branch for %s", repo.Remote())
+	// Svn and Bzr don't have default branches.
+	if repo.Vcs() == v.Svn || repo.Vcs() == v.Bzr {
+		return ""
+	}
+
+	if repo.Vcs() == v.Git {
+		c := exec.Command("git", "symbolic-ref", "--short", "HEAD")
+		c.Dir = repo.LocalPath()
+		c.Env = envForDir(c.Dir)
+		out, err := c.CombinedOutput()
+		if err != nil {
+			msg.Debug("Unable to find current branch for %s, error: %s", repo.Remote(), err)
+			return ""
+		}
+		return strings.TrimSpace(string(out))
+	}
+
+	if repo.Vcs() == v.Hg {
+		c := exec.Command("hg", "branch")
+		c.Dir = repo.LocalPath()
+		c.Env = envForDir(c.Dir)
+		out, err := c.CombinedOutput()
+		if err != nil {
+			msg.Debug("Unable to find current branch for %s, error: %s", repo.Remote(), err)
+			return ""
+		}
+		return strings.TrimSpace(string(out))
+	}
+
+	return ""
+}
+
+func envForDir(dir string) []string {
+	env := os.Environ()
+	return mergeEnvLists([]string{"PWD=" + dir}, env)
+}
+
+func mergeEnvLists(in, out []string) []string {
+NextVar:
+	for _, inkv := range in {
+		k := strings.SplitAfterN(inkv, "=", 2)[0]
+		for i, outkv := range out {
+			if strings.HasPrefix(outkv, k) {
+				out[i] = inkv
+				continue NextVar
+			}
+		}
+		out = append(out, inkv)
+	}
+	return out
+}
diff --git a/repo/vendored_cleanup.go b/repo/vendored_cleanup.go
new file mode 100644
index 0000000..de464d6
--- /dev/null
+++ b/repo/vendored_cleanup.go
@@ -0,0 +1,43 @@
+package repo
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+)
+
+// VendoredCleanUp cleans up vendored codebases after an update.
+//
+// This should _only_ be run for installations that do not want VCS repos inside
+// of the vendor/ directory.
+func VendoredCleanup(conf *cfg.Config) error {
+	vend, err := gpath.Vendor()
+	if err != nil {
+		return err
+	}
+
+	for _, dep := range conf.Imports {
+		if dep.UpdateAsVendored == true {
+			msg.Info("Cleaning up vendored package %s\n", dep.Name)
+
+			// Remove the VCS directory
+			cwd := filepath.Join(vend, dep.Name)
+			repo, err := dep.GetRepo(cwd)
+			if err != nil {
+				msg.Error("Error cleaning up %s:%s", dep.Name, err)
+				continue
+			}
+			t := repo.Vcs()
+			err = os.RemoveAll(cwd + string(os.PathSeparator) + "." + string(t))
+			if err != nil {
+				msg.Error("Error cleaning up VCS dir for %s:%s", dep.Name, err)
+			}
+		}
+
+	}
+
+	return nil
+}
diff --git a/testdata/name/glide.yaml b/testdata/name/glide.yaml
new file mode 100644
index 0000000..8987dfb
--- /dev/null
+++ b/testdata/name/glide.yaml
@@ -0,0 +1,2 @@
+package: technosophos.com/x/foo
+import: []
diff --git a/testdata/name/glide2.yaml b/testdata/name/glide2.yaml
new file mode 100644
index 0000000..29d8780
--- /dev/null
+++ b/testdata/name/glide2.yaml
@@ -0,0 +1,2 @@
+package: another/name
+import: []
diff --git a/testdata/nv/a/foo.empty b/testdata/nv/a/foo.empty
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/testdata/nv/a/foo.empty
diff --git a/testdata/nv/b/foo.empty b/testdata/nv/b/foo.empty
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/testdata/nv/b/foo.empty
diff --git a/testdata/nv/c/foo.empty b/testdata/nv/c/foo.empty
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/testdata/nv/c/foo.empty
diff --git a/testdata/path/a/b/c/placeholder.empty b/testdata/path/a/b/c/placeholder.empty
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/testdata/path/a/b/c/placeholder.empty
diff --git a/testdata/path/a/glide.yaml b/testdata/path/a/glide.yaml
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/testdata/path/a/glide.yaml
diff --git a/testdata/plugin/glide-hello b/testdata/plugin/glide-hello
new file mode 100755
index 0000000..e9d6e69
--- /dev/null
+++ b/testdata/plugin/glide-hello
@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "Hello from the other glide"
diff --git a/testdata/rebuild/glide.yaml b/testdata/rebuild/glide.yaml
new file mode 100644
index 0000000..7d204f1
--- /dev/null
+++ b/testdata/rebuild/glide.yaml
@@ -0,0 +1,3 @@
+package: github.com/Masterminds/glide/testdata/plugin
+import:
+  - package: example.com/x/foo
diff --git a/tree/tree.go b/tree/tree.go
new file mode 100644
index 0000000..0ba0d56
--- /dev/null
+++ b/tree/tree.go
@@ -0,0 +1,172 @@
+package tree
+
+import (
+	"container/list"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/Masterminds/glide/dependency"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/glide/util"
+)
+
+// Display displays a tree view of the given project.
+//
+// FIXME: The output formatting could use some TLC.
+func Display(b *util.BuildCtxt, basedir, myName string, level int, core bool, l *list.List) {
+	deps := walkDeps(b, basedir, myName)
+	for _, name := range deps {
+		found := findPkg(b, name, basedir)
+		if found.Loc == dependency.LocUnknown {
+			m := "glide get " + found.Name
+			msg.Puts("\t%s\t(%s)", found.Name, m)
+			continue
+		}
+		if !core && found.Loc == dependency.LocGoroot || found.Loc == dependency.LocCgo {
+			continue
+		}
+		msg.Print(strings.Repeat("|\t", level-1) + "|-- ")
+
+		f := findInList(found.Name, l)
+		if f == true {
+			msg.Puts("(Recursion) %s   (%s)", found.Name, found.Path)
+		} else {
+			// Every branch in the tree is a copy to handle all the branches
+			cl := copyList(l)
+			cl.PushBack(found.Name)
+			msg.Puts("%s   (%s)", found.Name, found.Path)
+			Display(b, found.Path, found.Name, level+1, core, cl)
+		}
+	}
+}
+
+func walkDeps(b *util.BuildCtxt, base, myName string) []string {
+	externalDeps := []string{}
+	filepath.Walk(base, func(path string, fi os.FileInfo, err error) error {
+		if !dependency.IsSrcDir(fi) {
+			if fi.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		pkg, err := b.ImportDir(path, 0)
+		if err != nil {
+			if !strings.HasPrefix(err.Error(), "no buildable Go source") {
+				msg.Warn("Error: %s (%s)", err, path)
+				// Not sure if we should return here.
+				//return err
+			}
+		}
+
+		if pkg.Goroot {
+			return nil
+		}
+
+		for _, imp := range pkg.Imports {
+			//if strings.HasPrefix(imp, myName) {
+			////Info("Skipping %s because it is a subpackage of %s", imp, myName)
+			//continue
+			//}
+			if imp == myName {
+				continue
+			}
+			externalDeps = append(externalDeps, imp)
+		}
+
+		return nil
+	})
+	return externalDeps
+}
+
+func findPkg(b *util.BuildCtxt, name, cwd string) *dependency.PkgInfo {
+	var fi os.FileInfo
+	var err error
+	var p string
+
+	info := &dependency.PkgInfo{
+		Name: name,
+	}
+
+	// Recurse backward to scan other vendor/ directories
+	// If the cwd isn't an absolute path walking upwards looking for vendor/
+	// folders can get into an infinate loop.
+	abs, err := filepath.Abs(cwd)
+	if err != nil {
+		abs = cwd
+	}
+	if abs != "." {
+		// Previously there was a check on the loop that wd := "/". The path
+		// "/" is a POSIX path so this fails on Windows. Now the check is to
+		// make sure the same wd isn't seen twice. When the same wd happens
+		// more than once it's the beginning of looping on the same location
+		// which is the top level.
+		pwd := ""
+		for wd := abs; wd != pwd; wd = filepath.Dir(wd) {
+			pwd = wd
+
+			// Don't look for packages outside the GOPATH
+			// Note, the GOPATH may or may not end with the path separator.
+			// The output of filepath.Dir does not the the path separator on the
+			// end so we need to test both.
+			if wd == b.GOPATH || wd+string(os.PathSeparator) == b.GOPATH {
+				break
+			}
+			p = filepath.Join(wd, "vendor", name)
+			if fi, err = os.Stat(p); err == nil && (fi.IsDir() || gpath.IsLink(fi)) {
+				info.Path = p
+				info.Loc = dependency.LocVendor
+				info.Vendored = true
+				return info
+			}
+		}
+	}
+	// Check $GOPATH
+	for _, r := range strings.Split(b.GOPATH, ":") {
+		p = filepath.Join(r, "src", name)
+		if fi, err = os.Stat(p); err == nil && (fi.IsDir() || gpath.IsLink(fi)) {
+			info.Path = p
+			info.Loc = dependency.LocGopath
+			return info
+		}
+	}
+
+	// Check $GOROOT
+	for _, r := range strings.Split(b.GOROOT, ":") {
+		p = filepath.Join(r, "src", name)
+		if fi, err = os.Stat(p); err == nil && (fi.IsDir() || gpath.IsLink(fi)) {
+			info.Path = p
+			info.Loc = dependency.LocGoroot
+			return info
+		}
+	}
+
+	// Finally, if this is "C", we're dealing with cgo
+	if name == "C" {
+		info.Loc = dependency.LocCgo
+	}
+
+	return info
+}
+
+// copyList copies an existing list to a new list.
+func copyList(l *list.List) *list.List {
+	n := list.New()
+	for e := l.Front(); e != nil; e = e.Next() {
+		n.PushBack(e.Value.(string))
+	}
+	return n
+}
+
+// findInList searches a list haystack for a string needle.
+func findInList(n string, l *list.List) bool {
+	for e := l.Front(); e != nil; e = e.Next() {
+		if e.Value.(string) == n {
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/tree/tree_test.go b/tree/tree_test.go
new file mode 100644
index 0000000..19f1b62
--- /dev/null
+++ b/tree/tree_test.go
@@ -0,0 +1,34 @@
+/* Package tree contains functions for printing a dependency tree.
+
+The future of the tree functionality is uncertain, as it is neither core to
+the functionality of Glide, nor particularly complementary. Its principal use
+case is for debugging the generated dependency tree.
+
+Currently, the tree package builds its dependency tree in a slightly different
+way than the `dependency` package does. This should not make any practical
+difference, though code-wise it would be nice to change this over to use the
+`dependency` resolver.
+*/
+package tree
+
+import (
+	"container/list"
+	"testing"
+)
+
+func TestFindInTree(t *testing.T) {
+	l := list.New()
+	l.PushBack("github.com/Masterminds/glide")
+	l.PushBack("github.com/Masterminds/vcs")
+	l.PushBack("github.com/Masterminds/semver")
+
+	f := findInList("foo", l)
+	if f != false {
+		t.Error("findInList found true instead of false")
+	}
+
+	f = findInList("github.com/Masterminds/vcs", l)
+	if f != true {
+		t.Error("findInList found false instead of true")
+	}
+}
diff --git a/util/normalizename_test.go b/util/normalizename_test.go
new file mode 100644
index 0000000..fe1f77b
--- /dev/null
+++ b/util/normalizename_test.go
@@ -0,0 +1,21 @@
+package util
+
+import (
+	"testing"
+)
+
+func TestNormalizeName(t *testing.T) {
+	packages := map[string]string{
+		"github.com/Masterminds/cookoo/web/io/foo": "github.com/Masterminds/cookoo",
+		"golang.org/x/crypto/ssh":                  "golang.org/x/crypto",
+		"incomplete/example":                       "incomplete/example",
+		"net":                                      "net",
+	}
+	for start, expected := range packages {
+		if finish, extra := NormalizeName(start); expected != finish {
+			t.Errorf("Expected '%s', got '%s'", expected, finish)
+		} else if start != finish && start != finish+"/"+extra {
+			t.Errorf("Expected %s to end with %s", finish, extra)
+		}
+	}
+}
diff --git a/util/util.go b/util/util.go
index cd26d31..bf949c1 100644
--- a/util/util.go
+++ b/util/util.go
@@ -9,6 +9,7 @@
 	"net/url"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"regexp"
 	"strings"
 
@@ -228,9 +229,33 @@
 	build.Context
 }
 
+// PackageName attempts to determine the name of the base package.
+//
+// If resolution fails, this will return "main".
+func (b *BuildCtxt) PackageName(base string) string {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "main"
+	}
+
+	pkg, err := b.Import(base, cwd, 0)
+	if err != nil {
+		// There may not be any top level Go source files but the project may
+		// still be within the GOPATH.
+		if strings.HasPrefix(base, b.GOPATH) {
+			p := strings.TrimPrefix(base, b.GOPATH)
+			return strings.Trim(p, string(os.PathSeparator))
+		}
+	}
+
+	return pkg.ImportPath
+}
+
 // GetBuildContext returns a build context from go/build. When the $GOROOT
 // variable is not set in the users environment it sets the context's root
 // path to the path returned by 'go env GOROOT'.
+//
+// TODO: This should be moved to the `dependency` package.
 func GetBuildContext() (*BuildCtxt, error) {
 	buildContext := &BuildCtxt{build.Default}
 	if goRoot := os.Getenv("GOROOT"); len(goRoot) == 0 {
@@ -243,3 +268,33 @@
 	}
 	return buildContext, nil
 }
+
+// NormalizeName takes a package name and normalizes it to the top level package.
+//
+// For example, golang.org/x/crypto/ssh becomes golang.org/x/crypto. 'ssh' is
+// returned as extra data.
+//
+// FIXME: Is this deprecated?
+func NormalizeName(name string) (string, string) {
+	// Fastpath check if a name in the GOROOT. There is an issue when a pkg
+	// is in the GOROOT and GetRootFromPackage tries to look it up because it
+	// expects remote names.
+	b, err := GetBuildContext()
+	if err == nil {
+		p := filepath.Join(b.GOROOT, "src", name)
+		if _, err := os.Stat(p); err == nil {
+			return name, ""
+		}
+	}
+
+	root := GetRootFromPackage(name)
+	extra := strings.TrimPrefix(name, root)
+	if len(extra) > 0 && extra != "/" {
+		extra = strings.TrimPrefix(extra, "/")
+	} else {
+		// If extra is / (which is what it would be here) we want to return ""
+		extra = ""
+	}
+
+	return root, extra
+}