From c981abd295fbb8a93d712ccefc46027772f7f18a Mon Sep 17 00:00:00 2001
From: Martin Duhem <martin.duhem@gmail.com>
Date: Fri, 11 Sep 2015 11:00:34 +0200
Subject: [PATCH] Fix all imports

---
 build.sbt                                     |   7 +-
 .../actions/src/main/scala/sbt/CacheIvy.scala |  13 +-
 .../actions/src/main/scala/sbt/Compiler.scala | 170 +++++++++---------
 main/actions/src/main/scala/sbt/Console.scala |   8 +-
 main/actions/src/main/scala/sbt/Doc.scala     |  16 +-
 .../actions/src/main/scala/sbt/DotGraph.scala |   4 +
 .../src/main/scala/sbt/ForkTests.scala        |   4 +-
 main/actions/src/main/scala/sbt/Package.scala |   8 +-
 .../src/main/scala/sbt/RawCompileLike.scala   |  16 +-
 main/actions/src/main/scala/sbt/Sync.scala    |   9 +-
 .../src/main/scala/sbt/TestResultLogger.scala |   1 +
 main/actions/src/main/scala/sbt/Tests.scala   |   5 +-
 .../src/main/scala/sbt/compiler/Eval.scala    |   2 +
 .../test/scala/sbt/compiler/EvalTest.scala    |   2 +
 .../main/scala/sbt/BasicCommandStrings.scala  |   5 +-
 .../src/main/scala/sbt/BasicCommands.scala    |   8 +-
 .../src/main/scala/sbt/BasicKeys.scala        |   1 +
 main/command/src/main/scala/sbt/Command.scala |   5 +-
 .../src/main/scala/sbt/CommandUtil.scala      |   9 +-
 .../main/scala/sbt/ExceptionCategory.scala    |   2 +
 .../src/main/scala/sbt/Highlight.scala        |   4 +-
 .../command/src/main/scala/sbt/MainLoop.scala |   4 +
 main/command/src/main/scala/sbt/State.scala   |   5 +-
 main/command/src/main/scala/sbt/Watched.scala |   8 +-
 main/command/src/main/scala/xsbt/IPC.scala    |  70 ++++++++
 main/settings/src/main/scala/sbt/Append.scala |   1 +
 .../src/main/scala/sbt/ConfigKey.scala        |   2 +-
 main/settings/src/main/scala/sbt/Def.scala    |   9 +-
 .../src/main/scala/sbt/InputTask.scala        |   7 +-
 .../src/main/scala/sbt/Previous.scala         |   3 +-
 .../src/main/scala/sbt/Reference.scala        |   4 +-
 main/settings/src/main/scala/sbt/Scope.scala  |   4 +
 .../src/main/scala/sbt/ScopeAxis.scala        |   2 +-
 .../src/main/scala/sbt/Structure.scala        |  21 ++-
 .../src/main/scala/sbt/std/InputConvert.scala |   4 +-
 .../src/main/scala/sbt/std/InputWrapper.scala |   4 +-
 .../src/main/scala/sbt/std/SettingMacro.scala |   5 +-
 .../src/main/scala/sbt/std/TaskMacro.scala    |  17 +-
 .../src/test/scala/ScopedKeySpec.scala        |   1 +
 main/settings/src/test/scala/UsageTest.scala  |   3 +-
 main/src/main/scala/sbt/APIMappings.scala     |   8 +-
 main/src/main/scala/sbt/Act.scala             |   7 +-
 main/src/main/scala/sbt/AddSettings.scala     |   2 +-
 main/src/main/scala/sbt/Aggregation.scala     |   4 +-
 main/src/main/scala/sbt/Build.scala           |   2 +
 .../main/scala/sbt/BuildDependencies.scala    |   5 +-
 main/src/main/scala/sbt/BuildLoader.scala     |   6 +-
 main/src/main/scala/sbt/BuildPaths.scala      |   6 +-
 main/src/main/scala/sbt/BuildStructure.scala  |   8 +-
 main/src/main/scala/sbt/BuildUtil.scala       |   2 +
 main/src/main/scala/sbt/CommandStrings.scala  |   2 +
 main/src/main/scala/sbt/ConsoleProject.scala  |   4 +-
 main/src/main/scala/sbt/Cross.scala           |   7 +-
 main/src/main/scala/sbt/Defaults.scala        |  48 +++--
 .../scala/sbt/EvaluateConfigurations.scala    |   6 +-
 main/src/main/scala/sbt/EvaluateTask.scala    |   7 +-
 main/src/main/scala/sbt/Extracted.scala       |   3 +-
 main/src/main/scala/sbt/GCUtil.scala          |   1 +
 main/src/main/scala/sbt/GlobalPlugin.scala    |   3 +
 main/src/main/scala/sbt/Inspect.scala         |   2 +
 main/src/main/scala/sbt/IvyConsole.scala      |   7 +
 main/src/main/scala/sbt/KeyIndex.scala        |   7 +-
 main/src/main/scala/sbt/Keys.scala            |  49 ++++-
 main/src/main/scala/sbt/Load.scala            |  16 +-
 main/src/main/scala/sbt/LogManager.scala      |   4 +-
 main/src/main/scala/sbt/Main.scala            |   6 +-
 main/src/main/scala/sbt/Opts.scala            |   4 +
 main/src/main/scala/sbt/Output.scala          |   4 +
 main/src/main/scala/sbt/PluginDiscovery.scala |   4 +
 .../src/main/scala/sbt/PluginManagement.scala |   1 +
 main/src/main/scala/sbt/Plugins.scala         |   7 +-
 main/src/main/scala/sbt/PluginsDebug.scala    |   5 +-
 main/src/main/scala/sbt/Project.scala         |   7 +-
 .../main/scala/sbt/ProjectNavigation.scala    |   4 +-
 main/src/main/scala/sbt/Resolve.scala         |   2 +
 main/src/main/scala/sbt/Resolvers.scala       |   6 +
 main/src/main/scala/sbt/RichURI.scala         |  54 ++++++
 main/src/main/scala/sbt/ScopeFilter.scala     |   6 +-
 main/src/main/scala/sbt/ScopedKeyData.scala   |   2 +-
 main/src/main/scala/sbt/Script.scala          |   6 +
 main/src/main/scala/sbt/SessionSettings.scala |   4 +
 main/src/main/scala/sbt/SessionVar.scala      |   2 +
 .../main/scala/sbt/SettingCompletions.scala   |   4 +
 main/src/main/scala/sbt/SettingGraph.scala    |   7 +-
 main/src/main/scala/sbt/TaskTimings.scala     |   2 +
 main/src/main/scala/sbt/dsl/package.scala     |   4 +-
 .../src/main/scala/sbt/internals/DslAst.scala |   4 +
 .../sbt/internals/parser/SbtParser.scala      |  12 +-
 .../sbt/plugins/JUnitXmlReportPlugin.scala    |   4 +-
 .../main/scala/sbt/plugins/JvmPlugin.scala    |   4 +-
 main/src/test/scala/Delegates.scala           |   4 +-
 main/src/test/scala/ParseKey.scala            |   2 +-
 main/src/test/scala/PluginCommandTest.scala   |   2 +
 main/src/test/scala/PluginsTest.scala         |   1 +
 main/src/test/scala/TestBuild.scala           |   5 +-
 .../internals/parser/EmbeddedXmlSpec.scala    |   2 +-
 .../sbt/internals/parser/ErrorSpec.scala      |   3 +-
 .../EvaluateConfigurationsOriginal.scala      |   5 +-
 .../internals/parser/SplitExpressions.scala   |   2 +-
 .../parser/SplitExpressionsFilesTest.scala    |  21 +--
 run/src/main/scala/sbt/Fork.scala             |   7 +-
 run/src/main/scala/sbt/Run.scala              |   4 +
 run/src/main/scala/sbt/TrapExit.scala         |   2 +
 run/src/test/scala/sbt/ForkTest.scala         |  12 +-
 .../internal/SbtArtifactDescriptorReader.java |   6 +-
 .../scala/sbt/MavenResolverConverter.scala    |   2 +
 .../scala/sbt/mavenint/FileTransport.scala    |   8 +-
 .../scala/sbt/mavenint/HttpTransport.scala    |   4 +-
 .../MavenCacheRepositoryResolver.scala        |   8 +-
 .../MavenRemoteRepositoryResolver.scala       |   7 +-
 .../mavenint/MavenRepositoryResolver.scala    |  11 +-
 .../sbt/mavenint/SbtRepositoryLayout.scala    |   4 +-
 .../src/test/scala/MavenResolutionSpec.scala  |  96 +++++-----
 sbt/src/main/scala/ProcessExtra.scala         |  17 ++
 sbt/src/main/scala/package.scala              |   9 +-
 .../main/scala/xsbt/test/FileCommands.scala   |   5 +-
 .../scala/xsbt/test/TestScriptParser.scala    |   4 +-
 .../scala/xsbt/test/FileCommandsSpec.scala    |   3 +-
 .../src/main/scala/sbt/ScriptedPlugin.scala   |   6 +-
 .../src/main/scala/sbt/test/SbtHandler.scala  |  10 +-
 .../main/scala/sbt/test/ScriptedTests.scala   |   7 +-
 .../scala/sbt/ConcurrentRestrictions.scala    |   4 +-
 tasks/src/main/scala/sbt/Execute.scala        |   5 +-
 .../src/main/scala/sbt/ExecuteProgress.scala  |   4 +-
 tasks/src/main/scala/sbt/Incomplete.scala     |   3 +-
 tasks/src/main/scala/sbt/Node.scala           |   3 +-
 tasks/src/main/scala/sbt/Result.scala         |   4 +-
 .../standard/src/main/scala/sbt/Action.scala  |   5 +-
 .../src/main/scala/sbt/std/Streams.scala      |   6 +-
 .../src/main/scala/sbt/std/System.scala       |   3 +-
 .../src/main/scala/sbt/std/TaskExtra.scala    |   8 +-
 .../standard/src/test/scala/TaskSerial.scala  |   4 +-
 tasks/standard/src/test/scala/Test.scala      |   3 +-
 .../src/test/scala/TestRunnerSort.scala       |   4 +-
 .../src/main/scala/sbt/TestFramework.scala    |   2 +
 .../main/scala/sbt/TestReportListener.scala   |  12 +-
 .../main/scala/sbt/TestStatusReporter.scala   |   1 +
 137 files changed, 860 insertions(+), 344 deletions(-)
 create mode 100644 main/command/src/main/scala/xsbt/IPC.scala
 create mode 100644 main/src/main/scala/sbt/RichURI.scala
 create mode 100644 sbt/src/main/scala/ProcessExtra.scala

diff --git a/build.sbt b/build.sbt
index 8f6aba6e6..f480e0270 100644
--- a/build.sbt
+++ b/build.sbt
@@ -11,7 +11,8 @@ def buildLevelSettings: Seq[Setting[_]] = inThisBuild(Seq(
   bintrayOrganization := Some(if (publishStatus.value == "releases") "typesafe" else "sbt"),
   bintrayRepository := s"ivy-${publishStatus.value}",
   bintrayPackage := "sbt",
-  bintrayReleaseOnPublish := false
+  bintrayReleaseOnPublish := false,
+  resolvers += Resolver.mavenLocal
 ))
 
 def commonSettings: Seq[Setting[_]] = Seq(
@@ -129,7 +130,7 @@ lazy val scriptedBaseProj = (project in scriptedPath / "base").
   )
 
 lazy val scriptedSbtProj = (project in scriptedPath / "sbt").
-  dependsOn(scriptedBaseProj).
+  dependsOn(scriptedBaseProj, commandProj).
   settings(
     baseSettings,
     name := "Scripted sbt",
@@ -202,7 +203,7 @@ lazy val mavenResolverPluginProj = (project in file("sbt-maven-resolver")).
   settings(
     baseSettings,
     name := "sbt-maven-resolver",
-    libraryDependencies ++= aetherLibs ++ Seq((libraryManagement % Test).classifier("tests")),
+    libraryDependencies ++= aetherLibs ++ Seq(utilTesting % Test, (libraryManagement % Test).classifier("tests"), libraryManagement % Test),
     sbtPlugin := true
   )
 
diff --git a/main/actions/src/main/scala/sbt/CacheIvy.scala b/main/actions/src/main/scala/sbt/CacheIvy.scala
index 8560fcab4..353dcbcbd 100644
--- a/main/actions/src/main/scala/sbt/CacheIvy.scala
+++ b/main/actions/src/main/scala/sbt/CacheIvy.scala
@@ -5,16 +5,23 @@ package sbt
 
 import Predef.{ Map, Set, implicitly } // excludes *both 2.10.x conforms and 2.11.x $conforms in source compatible manner.
 
-import FileInfo.{ exists, hash }
+import sbt.internal.util.{ Cache, HList, HNil, InputCache, LinePosition, LineRange, NoPosition, RangePosition, SourcePosition }
+import sbt.internal.util.FileInfo.{ exists, hash }
+import sbt.internal.util.Types.{ :+:, idFun }
 import java.io.File
 import java.{ util => ju }
 import java.net.URL
-import Types.{ :+:, idFun }
 import scala.xml.NodeSeq
 import sbinary.{ DefaultProtocol, Format }
-import RepositoryHelpers._
+// import sbt.internal.librarymanagement.{ ExternalIvyConfiguration, IvyConfiguration, IvyPaths, IvyScala, ModuleSettings, RetrieveConfiguration, SbtExclusionRule, UpdateConfiguration, UpdateReport }
+// import sbt.librarymanagement.{ Configuration, ExclusionRule, CrossVersion, ModuleID, Patterns }
+import sbt.internal.librarymanagement._
+import sbt.librarymanagement._
+import sbt.librarymanagement.RepositoryHelpers._
 import Ordering._
 
+import sbt.io.Hash
+
 /**
  * InputCaches for IvyConfiguration, ModuleSettings, and UpdateConfiguration
  * The InputCaches for a basic data structure is built in two parts.
diff --git a/main/actions/src/main/scala/sbt/Compiler.scala b/main/actions/src/main/scala/sbt/Compiler.scala
index 5953c2a54..277d9a0a8 100644
--- a/main/actions/src/main/scala/sbt/Compiler.scala
+++ b/main/actions/src/main/scala/sbt/Compiler.scala
@@ -12,6 +12,10 @@ import inc._
 import Locate.DefinesClass
 import java.io.File
 
+import sbt.internal.librarymanagement.{ ComponentManager, IvyConfiguration }
+import sbt.librarymanagement.ModuleID
+import sbt.util.Logger
+
 object Compiler {
   val DefaultMaxErrors = 100
 
@@ -45,94 +49,100 @@ object Compiler {
       incSetup
     )
 
-  def compilers(cpOptions: ClasspathOptions)(implicit app: AppConfiguration, log: Logger): Compilers =
-    {
-      val scalaProvider = app.provider.scalaProvider
-      compilers(ScalaInstance(scalaProvider.version, scalaProvider.launcher), cpOptions)
-    }
+  // def compilers(cpOptions: ClasspathOptions)(implicit app: AppConfiguration, log: Logger): Compilers =
+  //   {
+  //     val scalaProvider = app.provider.scalaProvider
+  //     compilers(ScalaInstance(scalaProvider.version, scalaProvider.launcher), cpOptions)
+  //   }
 
-  def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions)(implicit app: AppConfiguration, log: Logger): Compilers =
-    compilers(instance, cpOptions, None)
+  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions)(implicit app: AppConfiguration, log: Logger): Compilers =
+  //   compilers(instance, cpOptions, None)
 
-  @deprecated("Use `compilers(ScalaInstance, ClasspathOptions, Option[File], IvyConfiguration)`.", "0.13.10")
-  def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File])(implicit app: AppConfiguration, log: Logger): Compilers =
-    {
-      val javac =
-        AggressiveCompile.directOrFork(instance, cpOptions, javaHome)
-      val javac2 =
-        JavaTools.directOrFork(instance, cpOptions, javaHome)
-      // Hackery to enable both the new and deprecated APIs to coexist peacefully.
-      case class CheaterJavaTool(newJavac: IncrementalCompilerJavaTools, delegate: JavaTool) extends JavaTool with JavaToolWithNewInterface {
-        def compile(contract: JavacContract, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger): Unit =
-          javac.compile(contract, sources, classpath, outputDirectory, options)(log)
-        def onArgs(f: Seq[String] => Unit): JavaTool = CheaterJavaTool(newJavac, delegate.onArgs(f))
-      }
-      compilers(instance, cpOptions, CheaterJavaTool(javac2, javac))
-    }
-  def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration)(implicit app: AppConfiguration, log: Logger): Compilers =
-    {
-      val javac =
-        AggressiveCompile.directOrFork(instance, cpOptions, javaHome)
-      val javac2 =
-        JavaTools.directOrFork(instance, cpOptions, javaHome)
-      // Hackery to enable both the new and deprecated APIs to coexist peacefully.
-      case class CheaterJavaTool(newJavac: IncrementalCompilerJavaTools, delegate: JavaTool) extends JavaTool with JavaToolWithNewInterface {
-        def compile(contract: JavacContract, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger): Unit =
-          javac.compile(contract, sources, classpath, outputDirectory, options)(log)
-        def onArgs(f: Seq[String] => Unit): JavaTool = CheaterJavaTool(newJavac, delegate.onArgs(f))
-      }
-      val scalac = scalaCompiler(instance, cpOptions, ivyConfiguration)
-      new Compilers(scalac, CheaterJavaTool(javac2, javac))
-    }
-  @deprecated("Deprecated in favor of new sbt.compiler.javac package.", "0.13.8")
-  def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: sbt.compiler.JavaCompiler.Fork)(implicit app: AppConfiguration, log: Logger): Compilers =
-    {
-      val javaCompiler = sbt.compiler.JavaCompiler.fork(cpOptions, instance)(javac)
-      compilers(instance, cpOptions, javaCompiler)
-    }
-  @deprecated("Deprecated in favor of new sbt.compiler.javac package.", "0.13.8")
-  def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: JavaTool)(implicit app: AppConfiguration, log: Logger): Compilers =
-    {
-      val scalac = scalaCompiler(instance, cpOptions)
-      new Compilers(scalac, javac)
-    }
-  @deprecated("Use `scalaCompiler(ScalaInstance, ClasspathOptions, IvyConfiguration)`.", "0.13.10")
-  def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler =
+  // @deprecated("Use `compilers(ScalaInstance, ClasspathOptions, Option[File], IvyConfiguration)`.", "0.13.10")
+  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File])(implicit app: AppConfiguration, log: Logger): Compilers =
+  //   {
+  //     val javac =
+  //       AggressiveCompile.directOrFork(instance, cpOptions, javaHome)
+  //     val javac2 =
+  //       JavaTools.directOrFork(instance, cpOptions, javaHome)
+  //     // Hackery to enable both the new and deprecated APIs to coexist peacefully.
+  //     case class CheaterJavaTool(newJavac: IncrementalCompilerJavaTools, delegate: JavaTool) extends JavaTool with JavaToolWithNewInterface {
+  //       def compile(contract: JavacContract, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger): Unit =
+  //         javac.compile(contract, sources, classpath, outputDirectory, options)(log)
+  //       def onArgs(f: Seq[String] => Unit): JavaTool = CheaterJavaTool(newJavac, delegate.onArgs(f))
+  //     }
+  //     compilers(instance, cpOptions, CheaterJavaTool(javac2, javac))
+  //   }
+  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration)(implicit app: AppConfiguration, log: Logger): Compilers =
+  //   {
+  //     val javac =
+  //       AggressiveCompile.directOrFork(instance, cpOptions, javaHome)
+  //     val javac2 =
+  //       JavaTools.directOrFork(instance, cpOptions, javaHome)
+  //     // Hackery to enable both the new and deprecated APIs to coexist peacefully.
+  //     case class CheaterJavaTool(newJavac: IncrementalCompilerJavaTools, delegate: JavaTool) extends JavaTool with JavaToolWithNewInterface {
+  //       def compile(contract: JavacContract, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String])(implicit log: Logger): Unit =
+  //         javac.compile(contract, sources, classpath, outputDirectory, options)(log)
+  //       def onArgs(f: Seq[String] => Unit): JavaTool = CheaterJavaTool(newJavac, delegate.onArgs(f))
+  //     }
+  //     val scalac = scalaCompiler(instance, cpOptions, ivyConfiguration)
+  //     new Compilers(scalac, CheaterJavaTool(javac2, javac))
+  //   }
+  // @deprecated("Deprecated in favor of new sbt.compiler.javac package.", "0.13.8")
+  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: sbt.compiler.JavaCompiler.Fork)(implicit app: AppConfiguration, log: Logger): Compilers =
+  //   {
+  //     val javaCompiler = sbt.compiler.JavaCompiler.fork(cpOptions, instance)(javac)
+  //     compilers(instance, cpOptions, javaCompiler)
+  //   }
+  // @deprecated("Deprecated in favor of new sbt.compiler.javac package.", "0.13.8")
+  // def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javac: JavaTool)(implicit app: AppConfiguration, log: Logger): Compilers =
+  //   {
+  //     val scalac = scalaCompiler(instance, cpOptions)
+  //     new Compilers(scalac, javac)
+  //   }
+  // @deprecated("Use `scalaCompiler(ScalaInstance, ClasspathOptions, IvyConfiguration)`.", "0.13.10")
+  // def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler =
+  //   {
+  //     val launcher = app.provider.scalaProvider.launcher
+  //     val componentManager = new ComponentManager(launcher.globalLock, app.provider.components, Option(launcher.ivyHome), log)
+  //     val provider = ComponentCompiler.interfaceProvider(componentManager)
+  //     new AnalyzingCompiler(instance, provider, cpOptions)
+  //   }
+
+  // TODO: Get java compiler
+  def compilers(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): Compilers = {
+    val scalac = scalaCompiler(instance, cpOptions, javaHome, ivyConfiguration, sourcesModule)
+    val javac = ???
+    new Compilers(scalac, javac)
+  }
+  def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler =
     {
       val launcher = app.provider.scalaProvider.launcher
       val componentManager = new ComponentManager(launcher.globalLock, app.provider.components, Option(launcher.ivyHome), log)
-      val provider = ComponentCompiler.interfaceProvider(componentManager)
-      new AnalyzingCompiler(instance, provider, cpOptions)
-    }
-  def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions, ivyConfiguration: IvyConfiguration)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler =
-    {
-      val launcher = app.provider.scalaProvider.launcher
-      val componentManager = new ComponentManager(launcher.globalLock, app.provider.components, Option(launcher.ivyHome), log)
-      val bootDirectory = launcher.bootDirectory
-      val provider = ComponentCompiler.interfaceProvider(componentManager, ivyConfiguration, bootDirectory)
+      val provider = ComponentCompiler.interfaceProvider(componentManager, ivyConfiguration, sourcesModule)
       new AnalyzingCompiler(instance, provider, cpOptions)
     }
 
-  @deprecated("Use the `compile` method instead.", "0.13.8")
-  def apply(in: Inputs, log: Logger): Analysis = {
-    import in.config._
-    apply(in, log, new LoggerReporter(maxErrors, log, sourcePositionMapper))
-  }
-  @deprecated("Use the `compile` method instead.", "0.13.8")
-  def apply(in: Inputs, log: Logger, reporter: xsbti.Reporter): Analysis = {
-    import in.compilers._
-    import in.config._
-    import in.incSetup._
-    // Here we load the previous analysis since the new paths don't.
-    val (previousAnalysis, previousSetup) = {
-      MixedAnalyzingCompiler.staticCachedStore(cacheFile).get().map {
-        case (a, s) => (a, Some(s))
-      } getOrElse {
-        (Analysis.empty(nameHashing = incOptions.nameHashing), None)
-      }
-    }
-    compile(InputsWithPrevious(in, PreviousAnalysis(previousAnalysis, previousSetup)), log, reporter).analysis
-  }
+  // @deprecated("Use the `compile` method instead.", "0.13.8")
+  // def apply(in: Inputs, log: Logger): Analysis = {
+  //   import in.config._
+  //   apply(in, log, new LoggerReporter(maxErrors, log, sourcePositionMapper))
+  // }
+  // @deprecated("Use the `compile` method instead.", "0.13.8")
+  // def apply(in: Inputs, log: Logger, reporter: xsbti.Reporter): Analysis = {
+  //   import in.compilers._
+  //   import in.config._
+  //   import in.incSetup._
+  //   // Here we load the previous analysis since the new paths don't.
+  //   val (previousAnalysis, previousSetup) = {
+  //     MixedAnalyzingCompiler.staticCachedStore(cacheFile).get().map {
+  //       case (a, s) => (a, Some(s))
+  //     } getOrElse {
+  //       (Analysis.empty(nameHashing = incOptions.nameHashing), None)
+  //     }
+  //   }
+  //   compile(InputsWithPrevious(in, PreviousAnalysis(previousAnalysis, previousSetup)), log, reporter).analysis
+  // }
   def compile(in: InputsWithPrevious, log: Logger): CompileResult =
     {
       import in.inputs.config._
diff --git a/main/actions/src/main/scala/sbt/Console.scala b/main/actions/src/main/scala/sbt/Console.scala
index 21f6df18a..30f4f0fbc 100644
--- a/main/actions/src/main/scala/sbt/Console.scala
+++ b/main/actions/src/main/scala/sbt/Console.scala
@@ -5,6 +5,8 @@ package sbt
 
 import java.io.File
 import compiler.AnalyzingCompiler
+import sbt.internal.util.JLine
+import sbt.util.Logger
 
 final class Console(compiler: AnalyzingCompiler) {
   /** Starts an interactive scala interpreter session with the given classpath.*/
@@ -20,9 +22,11 @@ final class Console(compiler: AnalyzingCompiler) {
   def apply(classpath: Seq[File], options: Seq[String], initialCommands: String, cleanupCommands: String)(loader: Option[ClassLoader], bindings: Seq[(String, Any)])(implicit log: Logger): Option[String] =
     {
       def console0() = compiler.console(classpath, options, initialCommands, cleanupCommands, log)(loader, bindings)
-      JLine.withJLine(Run.executeTrapExit(console0, log))
+      // TODO: Fix JLine
+      //JLine.withJLine(Run.executeTrapExit(console0, log))
+      Run.executeTrapExit(console0, log)
     }
 }
 object Console {
   def apply(conf: Compiler.Inputs): Console = new Console(conf.compilers.scalac)
-}
\ No newline at end of file
+}
diff --git a/main/actions/src/main/scala/sbt/Doc.scala b/main/actions/src/main/scala/sbt/Doc.scala
index 822b14565..6100a5b79 100644
--- a/main/actions/src/main/scala/sbt/Doc.scala
+++ b/main/actions/src/main/scala/sbt/Doc.scala
@@ -7,13 +7,17 @@ import java.io.{ File, PrintWriter }
 import compiler.{ AnalyzingCompiler, JavaCompiler }
 
 import Predef.{ conforms => _, _ }
-import Types.:+:
-import Path._
+import sbt.internal.util.Types.:+:
+import sbt.io.Path._
+import sbt.io.IO
 
 import sbinary.DefaultProtocol.FileFormat
-import Cache.{ defaultEquiv, hConsCache, hNilCache, seqCache, seqFormat, streamFormat, StringFormat, UnitFormat, wrapIn }
-import Tracked.{ inputChanged, outputChanged }
-import FilesInfo.{ exists, hash, lastModified }
+import sbt.internal.util.Cache.{ defaultEquiv, hConsCache, hNilCache, seqCache, seqFormat, streamFormat, StringFormat, UnitFormat, wrapIn }
+import sbt.internal.util.Tracked.{ inputChanged, outputChanged }
+import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo }
+import sbt.internal.util.FilesInfo.{ exists, hash, lastModified }
+
+import sbt.util.Logger
 
 object Doc {
   import RawCompileLike._
@@ -66,7 +70,7 @@ sealed trait Doc {
           log.debug("Doc uptodate: " + outputDirectory.getAbsolutePath)
       }
     }
-    cachedDoc(inputs)(() => exists(outputDirectory.***.get.toSet))
+    cachedDoc(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
   }
 }
 @deprecated("No longer used.  See `Doc.scaladoc`", "0.13.0")
diff --git a/main/actions/src/main/scala/sbt/DotGraph.scala b/main/actions/src/main/scala/sbt/DotGraph.scala
index 06c2e1a84..f8dd51766 100644
--- a/main/actions/src/main/scala/sbt/DotGraph.scala
+++ b/main/actions/src/main/scala/sbt/DotGraph.scala
@@ -6,6 +6,10 @@ package sbt
 import java.io.{ File, Writer }
 import inc.Relations
 
+import sbt.internal.util.Relation
+
+import sbt.io.IO
+
 object DotGraph {
   private def fToString(roots: Iterable[File]): (File => String) =
     (x: File) => sourceToString(roots, x)
diff --git a/main/actions/src/main/scala/sbt/ForkTests.scala b/main/actions/src/main/scala/sbt/ForkTests.scala
index bb85025ab..6f78fee90 100755
--- a/main/actions/src/main/scala/sbt/ForkTests.scala
+++ b/main/actions/src/main/scala/sbt/ForkTests.scala
@@ -4,11 +4,13 @@
 package sbt
 
 import scala.collection.mutable
-import testing._
+import testing.{ Logger => _, _ }
 import java.net.ServerSocket
 import java.io._
 import Tests.{ Output => TestOutput, _ }
 import ForkMain._
+import sbt.io.IO
+import sbt.util.Logger
 
 private[sbt] object ForkTests {
   def apply(runners: Map[TestFramework, Runner], tests: List[TestDefinition], config: Execution, classpath: Seq[File], fork: ForkOptions, log: Logger): Task[TestOutput] = {
diff --git a/main/actions/src/main/scala/sbt/Package.scala b/main/actions/src/main/scala/sbt/Package.scala
index 8acdf93be..1f3c1c694 100644
--- a/main/actions/src/main/scala/sbt/Package.scala
+++ b/main/actions/src/main/scala/sbt/Package.scala
@@ -7,16 +7,20 @@ import Predef.{ conforms => _, _ }
 import java.io.File
 import java.util.jar.{ Attributes, Manifest }
 import collection.JavaConversions._
-import Types.:+:
-import Path._
+import sbt.internal.util.Types.:+:
+import sbt.io.Path._
+import sbt.io.IO
 
 import sbinary.{ DefaultProtocol, Format }
 import DefaultProtocol.{ FileFormat, immutableMapFormat, StringFormat, UnitFormat }
+import sbt.internal.util.{ Cache, FileInfo, FilesInfo, HNil, ModifiedFileInfo, PlainFileInfo, Tracked }
 import Cache.{ defaultEquiv, hConsCache, hNilCache, streamFormat, wrapIn }
 import Tracked.{ inputChanged, outputChanged }
 import FileInfo.exists
 import FilesInfo.lastModified
 
+import sbt.util.Logger
+
 sealed trait PackageOption
 object Package {
   final case class JarManifest(m: Manifest) extends PackageOption {
diff --git a/main/actions/src/main/scala/sbt/RawCompileLike.scala b/main/actions/src/main/scala/sbt/RawCompileLike.scala
index b538437da..638136d04 100644
--- a/main/actions/src/main/scala/sbt/RawCompileLike.scala
+++ b/main/actions/src/main/scala/sbt/RawCompileLike.scala
@@ -7,13 +7,17 @@ import java.io.File
 import compiler.{ AnalyzingCompiler, JavaCompiler }
 
 import Predef.{ conforms => _, _ }
-import Types.:+:
-import Path._
+import sbt.io.Path._
+import sbt.io.IO
 
 import sbinary.DefaultProtocol.FileFormat
-import Cache.{ defaultEquiv, hConsCache, hNilCache, IntFormat, seqCache, seqFormat, streamFormat, StringFormat, UnitFormat, wrapIn }
-import Tracked.{ inputChanged, outputChanged }
-import FilesInfo.{ exists, hash, lastModified }
+import sbt.internal.util.Types.:+:
+import sbt.internal.util.Cache.{ defaultEquiv, hConsCache, hNilCache, IntFormat, seqCache, seqFormat, streamFormat, StringFormat, UnitFormat, wrapIn }
+import sbt.internal.util.Tracked.{ inputChanged, outputChanged }
+import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo }
+import sbt.internal.util.FilesInfo.{ exists, hash, lastModified }
+
+import sbt.util.Logger
 
 object RawCompileLike {
   type Gen = (Seq[File], Seq[File], File, Seq[String], Int, Logger) => Unit
@@ -51,7 +55,7 @@ object RawCompileLike {
             log.debug("Uptodate: " + outputDirectory.getAbsolutePath)
         }
       }
-      cachedComp(inputs)(() => exists(outputDirectory.***.get.toSet))
+      cachedComp(inputs)(() => exists(outputDirectory.allPaths.get.toSet))
     }
   def prepare(description: String, doCompile: Gen): Gen = (sources, classpath, outputDirectory, options, maxErrors, log) =>
     {
diff --git a/main/actions/src/main/scala/sbt/Sync.scala b/main/actions/src/main/scala/sbt/Sync.scala
index 7e0f9f062..9f6f25c06 100644
--- a/main/actions/src/main/scala/sbt/Sync.scala
+++ b/main/actions/src/main/scala/sbt/Sync.scala
@@ -5,6 +5,10 @@ package sbt
 
 import java.io.File
 
+import sbt.internal.util.{ FileInfo, Relation }
+
+import sbt.io.IO
+
 /**
  * Maintains a set of mappings so that they are uptodate.
  * Specifically, 'apply' applies the mappings by creating target directories and copying source files to their destination.
@@ -71,7 +75,10 @@ object Sync {
   import sbinary._
   import Operations.{ read, write }
   import DefaultProtocol.{ FileFormat => _, _ }
-  import sbt.inc.AnalysisFormats.{ fileFormat, relationFormat }
+  //import sbt.inc.AnalysisFormats.{ fileFormat, relationFormat }
+  implicit def fileFormat: Format[File] = wrap[File, String](_.getAbsolutePath, s => new File(s))
+  implicit def relationFormat[A, B](implicit af: Format[Map[A, Set[B]]], bf: Format[Map[B, Set[A]]]): Format[Relation[A, B]] =
+    asProduct2[Relation[A, B], Map[A, Set[B]], Map[B, Set[A]]](Relation.make _)(r => (r.forwardMap, r.reverseMap))(af, bf)
 
   def writeInfo[F <: FileInfo](file: File, relation: Relation[File, File], info: Map[File, F])(implicit infoFormat: Format[F]): Unit =
     IO.gzipFileOut(file) { out =>
diff --git a/main/actions/src/main/scala/sbt/TestResultLogger.scala b/main/actions/src/main/scala/sbt/TestResultLogger.scala
index 01d7317a1..708e9c781 100644
--- a/main/actions/src/main/scala/sbt/TestResultLogger.scala
+++ b/main/actions/src/main/scala/sbt/TestResultLogger.scala
@@ -1,6 +1,7 @@
 package sbt
 
 import sbt.Tests.{ Output, Summary }
+import sbt.util.{ Level, Logger }
 
 /**
  * Logs information about tests after they finish.
diff --git a/main/actions/src/main/scala/sbt/Tests.scala b/main/actions/src/main/scala/sbt/Tests.scala
index 829b50c6d..b0d5d2274 100644
--- a/main/actions/src/main/scala/sbt/Tests.scala
+++ b/main/actions/src/main/scala/sbt/Tests.scala
@@ -7,7 +7,8 @@ import std._
 import xsbt.api.{ Discovered, Discovery }
 import inc.Analysis
 import TaskExtra._
-import Types._
+import sbt.internal.util.FeedbackProvidedException
+import sbt.internal.util.Types._
 import xsbti.api.Definition
 import ConcurrentRestrictions.Tag
 
@@ -16,6 +17,8 @@ import scala.annotation.tailrec
 
 import java.io.File
 
+import sbt.util.Logger
+
 sealed trait TestOption
 object Tests {
   /**
diff --git a/main/actions/src/main/scala/sbt/compiler/Eval.scala b/main/actions/src/main/scala/sbt/compiler/Eval.scala
index adeb042bf..fcaaa2b8f 100644
--- a/main/actions/src/main/scala/sbt/compiler/Eval.scala
+++ b/main/actions/src/main/scala/sbt/compiler/Eval.scala
@@ -14,6 +14,8 @@ import java.nio.ByteBuffer
 import java.net.URLClassLoader
 import Eval.{ getModule, getValue, WrapValName }
 
+import sbt.io.{ DirectoryFilter, FileFilter, GlobFilter, Hash, IO, Path }
+
 // TODO: provide a way to cleanup backing directory
 
 final class EvalImports(val strings: Seq[(String, Int)], val srcName: String)
diff --git a/main/actions/src/test/scala/sbt/compiler/EvalTest.scala b/main/actions/src/test/scala/sbt/compiler/EvalTest.scala
index 95c7d9309..415648f62 100644
--- a/main/actions/src/test/scala/sbt/compiler/EvalTest.scala
+++ b/main/actions/src/test/scala/sbt/compiler/EvalTest.scala
@@ -6,6 +6,8 @@ import org.scalacheck._
 import Prop._
 import scala.tools.nsc.reporters.StoreReporter
 
+import sbt.io.IO
+
 object EvalTest extends Properties("eval") {
   private[this] val reporter = new StoreReporter
   import reporter.{ ERROR, Info, Severity }
diff --git a/main/command/src/main/scala/sbt/BasicCommandStrings.scala b/main/command/src/main/scala/sbt/BasicCommandStrings.scala
index 76f79e623..389386c20 100644
--- a/main/command/src/main/scala/sbt/BasicCommandStrings.scala
+++ b/main/command/src/main/scala/sbt/BasicCommandStrings.scala
@@ -3,11 +3,12 @@
  */
 package sbt
 
-import complete.HistoryCommands
+import sbt.util.Level
+import sbt.internal.util.complete.HistoryCommands
 import scala.annotation.tailrec
 
 import java.io.File
-import Path._
+import sbt.io.Path._
 
 object BasicCommandStrings {
   val HelpCommand = "help"
diff --git a/main/command/src/main/scala/sbt/BasicCommands.scala b/main/command/src/main/scala/sbt/BasicCommands.scala
index ec81efba9..fafcf2df7 100644
--- a/main/command/src/main/scala/sbt/BasicCommands.scala
+++ b/main/command/src/main/scala/sbt/BasicCommands.scala
@@ -1,9 +1,10 @@
 package sbt
 
-import complete.{ Completion, Completions, DefaultParsers, HistoryCommands, Parser, TokenCompletions }
+import sbt.internal.util.{ AttributeKey, FullReader }
+import sbt.internal.util.complete.{ Completion, Completions, DefaultParsers, History => CHistory, HistoryCommands, Parser, TokenCompletions }
+import sbt.internal.util.Types.{ const, idFun }
 import classpath.ClasspathUtilities.toLoader
 import DefaultParsers._
-import Types.{ const, idFun }
 import Function.tupled
 import Command.applyEffect
 import HistoryCommands.{ Start => HistoryPrefix }
@@ -12,6 +13,7 @@ import CommandUtil._
 import BasicKeys._
 
 import java.io.File
+import sbt.io.IO
 
 import scala.util.control.NonFatal
 
@@ -159,7 +161,7 @@ object BasicCommands {
       val logError = (msg: String) => s.log.error(msg)
       val hp = s get historyPath getOrElse None
       val lines = hp.toList.flatMap(p => IO.readLines(p)).toIndexedSeq
-      histFun(complete.History(lines, hp, logError)) match {
+      histFun(CHistory(lines, hp, logError)) match {
         case Some(commands) =>
           commands foreach println //printing is more appropriate than logging
           (commands ::: s).continue
diff --git a/main/command/src/main/scala/sbt/BasicKeys.scala b/main/command/src/main/scala/sbt/BasicKeys.scala
index 6e7779558..844437934 100644
--- a/main/command/src/main/scala/sbt/BasicKeys.scala
+++ b/main/command/src/main/scala/sbt/BasicKeys.scala
@@ -1,6 +1,7 @@
 package sbt
 
 import java.io.File
+import sbt.internal.util.AttributeKey
 
 object BasicKeys {
   val historyPath = AttributeKey[Option[File]]("history", "The location where command line history is persisted.", 40)
diff --git a/main/command/src/main/scala/sbt/Command.scala b/main/command/src/main/scala/sbt/Command.scala
index 2da40fcc4..d0949e4f0 100644
--- a/main/command/src/main/scala/sbt/Command.scala
+++ b/main/command/src/main/scala/sbt/Command.scala
@@ -4,8 +4,9 @@
 package sbt
 
 import java.io.File
-import complete.{ DefaultParsers, EditDistance, Parser }
-import Types.const
+import sbt.internal.util.complete.{ DefaultParsers, EditDistance, Parser }
+import sbt.internal.util.Types.const
+import sbt.internal.util.{ AttributeKey, AttributeMap, Util }
 
 sealed trait Command {
   def help: State => Help
diff --git a/main/command/src/main/scala/sbt/CommandUtil.scala b/main/command/src/main/scala/sbt/CommandUtil.scala
index e2bc9f945..f2f53943c 100644
--- a/main/command/src/main/scala/sbt/CommandUtil.scala
+++ b/main/command/src/main/scala/sbt/CommandUtil.scala
@@ -3,8 +3,11 @@ package sbt
 import java.io.File
 import java.util.regex.{ Pattern, PatternSyntaxException }
 
-import complete.Parser
-import complete.DefaultParsers._
+import sbt.internal.util.AttributeKey
+import sbt.internal.util.complete.Parser
+import sbt.internal.util.complete.DefaultParsers._
+
+import sbt.io.IO
 
 object CommandUtil {
   def readLines(files: Seq[File]): Seq[String] = files flatMap (line => IO.readLines(line)) flatMap processLine
@@ -71,4 +74,4 @@ object CommandUtil {
 
   final val HelpPatternFlags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE
 
-}
\ No newline at end of file
+}
diff --git a/main/command/src/main/scala/sbt/ExceptionCategory.scala b/main/command/src/main/scala/sbt/ExceptionCategory.scala
index 699f247f2..247cf7af3 100644
--- a/main/command/src/main/scala/sbt/ExceptionCategory.scala
+++ b/main/command/src/main/scala/sbt/ExceptionCategory.scala
@@ -3,6 +3,8 @@ package sbt
 import java.lang.reflect.InvocationTargetException
 import scala.annotation.tailrec
 
+import sbt.internal.util.{ AlreadyHandledException, MessageOnlyException, UnprintableException }
+
 private[sbt] sealed abstract class ExceptionCategory {
   def isFull: Boolean = false
 }
diff --git a/main/command/src/main/scala/sbt/Highlight.scala b/main/command/src/main/scala/sbt/Highlight.scala
index ae58566ea..91748f7c8 100644
--- a/main/command/src/main/scala/sbt/Highlight.scala
+++ b/main/command/src/main/scala/sbt/Highlight.scala
@@ -3,6 +3,8 @@ package sbt
 import java.util.regex.Pattern
 import scala.Console.{ BOLD, RESET }
 
+import sbt.internal.util.ConsoleLogger
+
 object Highlight {
   final val NormalIntensity = "\033[22m"
   final val NormalTextColor = "\033[39m"
@@ -19,4 +21,4 @@ object Highlight {
         None
     }
   def bold(s: String) = if (ConsoleLogger.formatEnabled) BOLD + s + NormalIntensity else s
-}
\ No newline at end of file
+}
diff --git a/main/command/src/main/scala/sbt/MainLoop.scala b/main/command/src/main/scala/sbt/MainLoop.scala
index 488decab0..1ac6ccf23 100644
--- a/main/command/src/main/scala/sbt/MainLoop.scala
+++ b/main/command/src/main/scala/sbt/MainLoop.scala
@@ -7,6 +7,10 @@ import scala.annotation.tailrec
 import java.io.{ File, PrintWriter }
 import jline.TerminalFactory
 
+import sbt.internal.io.Using
+import sbt.internal.util.{ ErrorHandling, GlobalLogBacking, GlobalLogging }
+import sbt.util.{ AbstractLogger, Logger }
+
 object MainLoop {
   /** Entry point to run the remaining commands in State with managed global logging.*/
   def runLogged(state: State): xsbti.MainResult = {
diff --git a/main/command/src/main/scala/sbt/State.scala b/main/command/src/main/scala/sbt/State.scala
index 3e88a8db9..ed8176ff1 100644
--- a/main/command/src/main/scala/sbt/State.scala
+++ b/main/command/src/main/scala/sbt/State.scala
@@ -5,6 +5,9 @@ package sbt
 
 import java.io.File
 import java.util.concurrent.Callable
+import sbt.util.Logger
+import sbt.internal.util.{ AttributeKey, AttributeMap, ErrorHandling, ExitHook, ExitHooks, GlobalLogging }
+import sbt.internal.util.complete.HistoryCommands
 
 /**
  * Data structure representing all command execution information.
@@ -166,7 +169,7 @@ object State {
     def previous: Option[String] = executed.drop(1).headOption
   }
   /** Constructs an empty command History with a default, finite command limit.*/
-  def newHistory = new History(Vector.empty, complete.HistoryCommands.MaxLines)
+  def newHistory = new History(Vector.empty, HistoryCommands.MaxLines)
 
   def defaultReload(state: State): Reboot =
     {
diff --git a/main/command/src/main/scala/sbt/Watched.scala b/main/command/src/main/scala/sbt/Watched.scala
index d8ef89605..2b2a4fa85 100644
--- a/main/command/src/main/scala/sbt/Watched.scala
+++ b/main/command/src/main/scala/sbt/Watched.scala
@@ -7,7 +7,11 @@ import BasicCommandStrings.ClearOnFailure
 import State.FailureWall
 import annotation.tailrec
 import java.io.File
-import Types.const
+
+import sbt.io.PathFinder
+import sbt.internal.io.{ SourceModificationWatch, WatchState }
+import sbt.internal.util.AttributeKey
+import sbt.internal.util.Types.const
 
 trait Watched {
   /** The files watched when an action is run with a preceeding ~ */
@@ -77,4 +81,4 @@ object Watched {
     }
   val ContinuousState = AttributeKey[WatchState]("watch state", "Internal: tracks state for continuous execution.")
   val Configuration = AttributeKey[Watched]("watched-configuration", "Configures continuous execution.")
-}
\ No newline at end of file
+}
diff --git a/main/command/src/main/scala/xsbt/IPC.scala b/main/command/src/main/scala/xsbt/IPC.scala
new file mode 100644
index 000000000..47e2fb1a1
--- /dev/null
+++ b/main/command/src/main/scala/xsbt/IPC.scala
@@ -0,0 +1,70 @@
+/* sbt -- Simple Build Tool
+ * Copyright 2009 Mark Harrah
+ */
+package xsbt
+
+import java.io.{ BufferedReader, BufferedWriter, InputStream, InputStreamReader, OutputStreamWriter, OutputStream }
+import java.net.{ InetAddress, ServerSocket, Socket }
+
+object IPC {
+  private val portMin = 1025
+  private val portMax = 65536
+  private val loopback = InetAddress.getByName(null) // loopback
+
+  def client[T](port: Int)(f: IPC => T): T =
+    ipc(new Socket(loopback, port))(f)
+
+  def pullServer[T](f: Server => T): T =
+    {
+      val server = makeServer
+      try { f(new Server(server)) }
+      finally { server.close() }
+    }
+  def unmanagedServer: Server = new Server(makeServer)
+  def makeServer: ServerSocket =
+    {
+      val random = new java.util.Random
+      def nextPort = random.nextInt(portMax - portMin + 1) + portMin
+      def createServer(attempts: Int): ServerSocket =
+        if (attempts > 0)
+          try { new ServerSocket(nextPort, 1, loopback) }
+          catch { case _: Exception => createServer(attempts - 1) }
+        else
+          sys.error("Could not connect to socket: maximum attempts exceeded")
+      createServer(10)
+    }
+  def server[T](f: IPC => Option[T]): T = serverImpl(makeServer, f)
+  def server[T](port: Int)(f: IPC => Option[T]): T =
+    serverImpl(new ServerSocket(port, 1, loopback), f)
+  private def serverImpl[T](server: ServerSocket, f: IPC => Option[T]): T =
+    {
+      def listen(): T =
+        {
+          ipc(server.accept())(f) match {
+            case Some(done) => done
+            case None       => listen()
+          }
+        }
+
+      try { listen() }
+      finally { server.close() }
+    }
+  private def ipc[T](s: Socket)(f: IPC => T): T =
+    try { f(new IPC(s)) }
+    finally { s.close() }
+
+  final class Server private[IPC] (s: ServerSocket) extends NotNull {
+    def port = s.getLocalPort
+    def close() = s.close()
+    def isClosed: Boolean = s.isClosed
+    def connection[T](f: IPC => T): T = IPC.ipc(s.accept())(f)
+  }
+}
+final class IPC private (s: Socket) extends NotNull {
+  def port = s.getLocalPort
+  private val in = new BufferedReader(new InputStreamReader(s.getInputStream))
+  private val out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream))
+
+  def send(s: String) = { out.write(s); out.newLine(); out.flush() }
+  def receive: String = in.readLine()
+}
diff --git a/main/settings/src/main/scala/sbt/Append.scala b/main/settings/src/main/scala/sbt/Append.scala
index ee7738b24..0d2f8062e 100644
--- a/main/settings/src/main/scala/sbt/Append.scala
+++ b/main/settings/src/main/scala/sbt/Append.scala
@@ -3,6 +3,7 @@ package sbt
 import java.io.File
 import Def.Classpath
 import scala.annotation.implicitNotFound
+import sbt.internal.util.Attributed
 
 object Append {
   @implicitNotFound(msg = "No implicit for Append.Value[${A}, ${B}] found,\n  so ${B} cannot be appended to ${A}")
diff --git a/main/settings/src/main/scala/sbt/ConfigKey.scala b/main/settings/src/main/scala/sbt/ConfigKey.scala
index 8acbb92ad..6dd75823c 100644
--- a/main/settings/src/main/scala/sbt/ConfigKey.scala
+++ b/main/settings/src/main/scala/sbt/ConfigKey.scala
@@ -2,5 +2,5 @@ package sbt
 
 final case class ConfigKey(name: String)
 object ConfigKey {
-  implicit def configurationToKey(c: Configuration): ConfigKey = ConfigKey(c.name)
+  implicit def configurationToKey(c: sbt.librarymanagement.Configuration): ConfigKey = ConfigKey(c.name)
 }
diff --git a/main/settings/src/main/scala/sbt/Def.scala b/main/settings/src/main/scala/sbt/Def.scala
index 5ae4e737a..8800843da 100644
--- a/main/settings/src/main/scala/sbt/Def.scala
+++ b/main/settings/src/main/scala/sbt/Def.scala
@@ -1,7 +1,8 @@
 package sbt
 
-import Types.const
-import complete.Parser
+import sbt.internal.util.Types.const
+import sbt.internal.util.{ Attributed, AttributeKey, Init, Show }
+import sbt.internal.util.complete.Parser
 import java.io.File
 import Scope.{ ThisScope, GlobalScope }
 import KeyRanks.{ DTask, Invisible }
@@ -59,7 +60,7 @@ object Def extends Init[Scope] with TaskMacroExtra {
    * A default Parser for splitting input into space-separated arguments.
    * `argLabel` is an optional, fixed label shown for an argument during tab completion.
    */
-  def spaceDelimited(argLabel: String = "<arg>"): Parser[Seq[String]] = complete.Parsers.spaceDelimited(argLabel)
+  def spaceDelimited(argLabel: String = "<arg>"): Parser[Seq[String]] = sbt.internal.util.complete.Parsers.spaceDelimited(argLabel)
 
   /** Lifts the result of a setting initialization into a Task. */
   def toITask[T](i: Initialize[T]): Initialize[Task[T]] = map(i)(std.TaskExtra.inlineTask)
@@ -117,4 +118,4 @@ trait TaskMacroExtra {
   implicit def macroValueIn[T](in: InputTask[T]): std.InputEvaluated[T] = ???
   implicit def parserToInput[T](in: Parser[T]): std.ParserInput[T] = ???
   implicit def stateParserToInput[T](in: State => Parser[T]): std.ParserInput[T] = ???
-}
\ No newline at end of file
+}
diff --git a/main/settings/src/main/scala/sbt/InputTask.scala b/main/settings/src/main/scala/sbt/InputTask.scala
index 4ccf76612..4c7e3bf1e 100644
--- a/main/settings/src/main/scala/sbt/InputTask.scala
+++ b/main/settings/src/main/scala/sbt/InputTask.scala
@@ -1,10 +1,11 @@
 package sbt
 
-import complete.Parser
+import sbt.internal.util.complete.Parser
 import Def.{ Initialize, ScopedKey }
 import std.TaskExtra.{ task => mktask, _ }
 import Task._
-import Types._
+import sbt.internal.util.{ ~>, AttributeKey, Types }
+import sbt.internal.util.Types._
 
 /** Parses input and produces a task to run.  Constructed using the companion object. */
 final class InputTask[T] private (val parser: State => Parser[Task[T]]) {
@@ -76,7 +77,7 @@ object InputTask {
     separate(p)(std.FullInstance.flattenFun[I, T](action))
 
   /** A dummy parser that consumes no input and produces nothing useful (unit).*/
-  def emptyParser: State => Parser[Unit] = Types.const(complete.DefaultParsers.success(()))
+  def emptyParser: State => Parser[Unit] = Types.const(sbt.internal.util.complete.DefaultParsers.success(()))
 
   /** Implementation detail that is public because it is used by a macro.*/
   def parserAsInput[T](p: Parser[T]): Initialize[State => Parser[T]] = Def.valueStrict(Types.const(p))
diff --git a/main/settings/src/main/scala/sbt/Previous.scala b/main/settings/src/main/scala/sbt/Previous.scala
index eb0376c61..565fa1394 100644
--- a/main/settings/src/main/scala/sbt/Previous.scala
+++ b/main/settings/src/main/scala/sbt/Previous.scala
@@ -2,7 +2,8 @@ package sbt
 
 import Def.{ Initialize, resolvedScoped, ScopedKey, Setting, streamsManagerKey }
 import Previous._
-import Types._
+import sbt.internal.util.{ ~>, AttributeKey, IMap, RMap }
+import sbt.internal.util.Types._
 
 import java.io.{ InputStream, OutputStream }
 import sbinary.{ DefaultProtocol, Format }
diff --git a/main/settings/src/main/scala/sbt/Reference.scala b/main/settings/src/main/scala/sbt/Reference.scala
index 296cc22cc..80055fc1a 100644
--- a/main/settings/src/main/scala/sbt/Reference.scala
+++ b/main/settings/src/main/scala/sbt/Reference.scala
@@ -6,6 +6,8 @@ package sbt
 import java.io.File
 import java.net.URI
 
+import sbt.io.IO
+
 // in all of these, the URI must be resolved and normalized before it is definitive
 
 /** Identifies a project or build. */
@@ -101,4 +103,4 @@ object Reference {
 
   @deprecated("Explicitly wrap the String in a call to LocalProject.", "0.13.0")
   implicit def stringToReference(s: String): ProjectReference = LocalProject(s)
-}
\ No newline at end of file
+}
diff --git a/main/settings/src/main/scala/sbt/Scope.scala b/main/settings/src/main/scala/sbt/Scope.scala
index 79e085bec..07c8ea802 100644
--- a/main/settings/src/main/scala/sbt/Scope.scala
+++ b/main/settings/src/main/scala/sbt/Scope.scala
@@ -6,6 +6,10 @@ package sbt
 import java.io.File
 import java.net.URI
 
+import sbt.internal.util.{ AttributeKey, AttributeMap, Dag }
+
+import sbt.io.IO
+
 final case class Scope(project: ScopeAxis[Reference], config: ScopeAxis[ConfigKey], task: ScopeAxis[AttributeKey[_]], extra: ScopeAxis[AttributeMap]) {
   def in(project: Reference, config: ConfigKey): Scope = copy(project = Select(project), config = Select(config))
   def in(config: ConfigKey, task: AttributeKey[_]): Scope = copy(config = Select(config), task = Select(task))
diff --git a/main/settings/src/main/scala/sbt/ScopeAxis.scala b/main/settings/src/main/scala/sbt/ScopeAxis.scala
index 2a17d2496..ce774c562 100644
--- a/main/settings/src/main/scala/sbt/ScopeAxis.scala
+++ b/main/settings/src/main/scala/sbt/ScopeAxis.scala
@@ -1,6 +1,6 @@
 package sbt
 
-import Types.some
+import sbt.internal.util.Types.some
 
 sealed trait ScopeAxis[+S] {
   def foldStrict[T](f: S => T, ifGlobal: T, ifThis: T): T = fold(f, ifGlobal, ifThis)
diff --git a/main/settings/src/main/scala/sbt/Structure.scala b/main/settings/src/main/scala/sbt/Structure.scala
index 56e08e2d2..307fa2df3 100644
--- a/main/settings/src/main/scala/sbt/Structure.scala
+++ b/main/settings/src/main/scala/sbt/Structure.scala
@@ -10,10 +10,12 @@ import java.net.URI
 
 import ConcurrentRestrictions.Tag
 import Def.{ Initialize, KeyedInitialize, ScopedKey, Setting, setting }
+import sbt.io.{ FileFilter, Path, PathFinder }
 import Path._
 import std.TaskExtra.{ task => mktask, _ }
 import Task._
-import Types._
+import sbt.internal.util.Types._
+import sbt.internal.util.{ ~>, AList, AttributeKey, Settings, SourcePosition }
 
 import language.experimental.macros
 import reflect.internal.annotations.compileTimeOnly
@@ -214,19 +216,20 @@ object Scoped {
   final class RichInitializeTask[S](i: Initialize[Task[S]]) extends RichInitTaskBase[S, Task] {
     protected def onTask[T](f: Task[S] => Task[T]): Initialize[Task[T]] = i apply f
 
-    def dependsOn(tasks: AnyInitTask*): Initialize[Task[S]] = (i, Initialize.joinAny[Task](tasks)) { (thisTask, deps) => thisTask.dependsOn(deps: _*) }
+    def dependsOn(tasks: AnyInitTask*): Initialize[Task[S]] = (i, Initialize.joinAny[Task, Any](tasks)) { (thisTask, deps) => thisTask.dependsOn(deps: _*) }
 
     def failure: Initialize[Task[Incomplete]] = i(_.failure)
     def result: Initialize[Task[Result[S]]] = i(_.result)
 
-    def triggeredBy(tasks: AnyInitTask*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy)
-    def runBefore(tasks: AnyInitTask*): Initialize[Task[S]] = nonLocal(tasks, Def.runBefore)
-    private[this] def nonLocal(tasks: Seq[AnyInitTask], key: AttributeKey[Seq[Task[_]]]): Initialize[Task[S]] =
-      (Initialize.joinAny[Task](tasks), i) { (ts, i) => i.copy(info = i.info.set(key, ts)) }
+    def xtriggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy)
+    def triggeredBy[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.triggeredBy)
+    def runBefore[T](tasks: Initialize[Task[T]]*): Initialize[Task[S]] = nonLocal(tasks, Def.runBefore)
+    private[this] def nonLocal[T](tasks: Seq[Initialize[Task[T]]], key: AttributeKey[Seq[Task[_]]]): Initialize[Task[S]] =
+      (Initialize.joinAny[Task, T](tasks), i) { (ts, i) => i.copy(info = i.info.set(key, ts)) }
   }
   final class RichInitializeInputTask[S](i: Initialize[InputTask[S]]) extends RichInitTaskBase[S, InputTask] {
     protected def onTask[T](f: Task[S] => Task[T]): Initialize[InputTask[T]] = i(_ mapTask f)
-    def dependsOn(tasks: AnyInitTask*): Initialize[InputTask[S]] = (i, Initialize.joinAny[Task](tasks)) { (thisTask, deps) => thisTask.mapTask(_.dependsOn(deps: _*)) }
+    def dependsOn(tasks: AnyInitTask*): Initialize[InputTask[S]] = (i, Initialize.joinAny[Task, Any](tasks)) { (thisTask, deps) => thisTask.mapTask(_.dependsOn(deps: _*)) }
   }
 
   sealed abstract class RichInitTaskBase[S, R[_]] {
@@ -256,7 +259,7 @@ object Scoped {
     def mapFailure[T](f: Incomplete => T): Initialize[R[T]] = mapR(f compose failM)
   }
 
-  type AnyInitTask = Initialize[Task[T]] forSome { type T }
+  type AnyInitTask = Initialize[Task[Any]] // forSome { type T }
 
   implicit def richTaskSeq[T](in: Seq[Initialize[Task[T]]]): RichTaskSeq[T] = new RichTaskSeq(in)
   final class RichTaskSeq[T](keys: Seq[Initialize[Task[T]]]) {
@@ -265,7 +268,7 @@ object Scoped {
   }
   implicit def richAnyTaskSeq(in: Seq[AnyInitTask]): RichAnyTaskSeq = new RichAnyTaskSeq(in)
   final class RichAnyTaskSeq(keys: Seq[AnyInitTask]) {
-    def dependOn: Initialize[Task[Unit]] = Initialize.joinAny[Task](keys).apply(deps => nop.dependsOn(deps: _*))
+    def dependOn: Initialize[Task[Unit]] = Initialize.joinAny[Task, Any](keys).apply(deps => nop.dependsOn(deps: _*))
   }
 
   implicit def richFileSetting(s: SettingKey[File]): RichFileSetting = new RichFileSetting(s)
diff --git a/main/settings/src/main/scala/sbt/std/InputConvert.scala b/main/settings/src/main/scala/sbt/std/InputConvert.scala
index e0b2ab23e..97b5794ac 100644
--- a/main/settings/src/main/scala/sbt/std/InputConvert.scala
+++ b/main/settings/src/main/scala/sbt/std/InputConvert.scala
@@ -6,8 +6,8 @@ import scala.reflect._
 import reflect.macros._
 
 import Def.Initialize
-import complete.Parser
-import appmacro.{ Convert, Converted }
+import sbt.internal.util.complete.Parser
+import sbt.internal.util.appmacro.{ Convert, Converted }
 
 object InputInitConvert extends Convert {
   def apply[T: c.WeakTypeTag](c: Context)(nme: String, in: c.Tree): Converted[c.type] =
diff --git a/main/settings/src/main/scala/sbt/std/InputWrapper.scala b/main/settings/src/main/scala/sbt/std/InputWrapper.scala
index 999a8172d..d84914efb 100644
--- a/main/settings/src/main/scala/sbt/std/InputWrapper.scala
+++ b/main/settings/src/main/scala/sbt/std/InputWrapper.scala
@@ -7,8 +7,8 @@ import reflect.macros._
 import reflect.internal.annotations.compileTimeOnly
 
 import Def.{ Initialize, ScopedKey }
-import appmacro.ContextUtil
-import complete.Parser
+import sbt.internal.util.appmacro.ContextUtil
+import sbt.internal.util.complete.Parser
 
 /** Implementation detail.  The wrap methods temporarily hold inputs (as a Tree, at compile time) until a task or setting macro processes it. */
 object InputWrapper {
diff --git a/main/settings/src/main/scala/sbt/std/SettingMacro.scala b/main/settings/src/main/scala/sbt/std/SettingMacro.scala
index d720adbf1..5f2ae6d85 100644
--- a/main/settings/src/main/scala/sbt/std/SettingMacro.scala
+++ b/main/settings/src/main/scala/sbt/std/SettingMacro.scala
@@ -2,8 +2,9 @@ package sbt
 package std
 
 import Def.{ Initialize, Setting }
-import Types.{ idFun, Id }
-import appmacro.{ Convert, Converted, Instance, MixedBuilder, MonadInstance }
+import sbt.internal.util.Types.{ idFun, Id }
+import sbt.internal.util.AList
+import sbt.internal.util.appmacro.{ Convert, Converted, Instance, MixedBuilder, MonadInstance }
 
 object InitializeInstance extends MonadInstance {
   type M[x] = Initialize[x]
diff --git a/main/settings/src/main/scala/sbt/std/TaskMacro.scala b/main/settings/src/main/scala/sbt/std/TaskMacro.scala
index 770eea263..460110bf2 100644
--- a/main/settings/src/main/scala/sbt/std/TaskMacro.scala
+++ b/main/settings/src/main/scala/sbt/std/TaskMacro.scala
@@ -2,11 +2,12 @@ package sbt
 package std
 
 import Def.{ Initialize, Setting }
-import Types.{ const, idFun, Id }
+import sbt.internal.util.Types.{ const, idFun, Id }
 import TaskExtra.allM
-import appmacro.{ ContextUtil, Convert, Converted, Instance, MixedBuilder, MonadInstance }
+import sbt.internal.util.appmacro.{ ContextUtil, Convert, Converted, Instance, MixedBuilder, MonadInstance }
 import Instance.Transform
-import complete.{ DefaultParsers, Parser }
+import sbt.internal.util.complete.{ DefaultParsers, Parser }
+import sbt.internal.util.{ AList, LinePosition, NoPosition, SourcePosition }
 
 import language.experimental.macros
 import scala.reflect._
@@ -24,7 +25,7 @@ object TaskInstance extends MonadInstance {
   def pure[T](t: () => T): Task[T] = toTask(t)
 }
 object ParserInstance extends Instance {
-  import sbt.Classes.Applicative
+  import sbt.internal.util.Classes.Applicative
   private[this] implicit val parserApplicative: Applicative[M] = new Applicative[M] {
     def apply[S, T](f: M[S => T], v: M[S]): M[T] = s => (f(s) ~ v(s)) map { case (a, b) => a(b) }
     def pure[S](s: => S) = const(Parser.success(s))
@@ -39,7 +40,7 @@ object ParserInstance extends Instance {
 
 /** Composes the Task and Initialize Instances to provide an Instance for [T] Initialize[Task[T]].*/
 object FullInstance extends Instance.Composed[Initialize, Task](InitializeInstance, TaskInstance) with MonadInstance {
-  type SS = sbt.Settings[Scope]
+  type SS = sbt.internal.util.Settings[Scope]
   val settingsData = TaskKey[SS]("settings-data", "Provides access to the project data for the build.", KeyRanks.DTask)
 
   def flatten[T](in: Initialize[Task[Initialize[Task[T]]]]): Initialize[Task[T]] =
@@ -222,15 +223,15 @@ object TaskMacro {
     }
   private[this] def sourcePosition(c: Context): c.Expr[SourcePosition] =
     {
-      import c.universe._
+      import c.universe.reify
       val pos = c.enclosingPosition
       if (pos.isDefined && pos.line >= 0 && pos.source != null) {
         val f = pos.source.file
         val name = constant[String](c, settingSource(c, f.path, f.name))
         val line = constant[Int](c, pos.line)
-        reify { sbt.LinePosition(name.splice, line.splice) }
+        reify { LinePosition(name.splice, line.splice) }
       } else
-        reify { sbt.NoPosition }
+        reify { NoPosition }
     }
   private[this] def settingSource(c: Context, path: String, name: String): String =
     {
diff --git a/main/settings/src/test/scala/ScopedKeySpec.scala b/main/settings/src/test/scala/ScopedKeySpec.scala
index c5d529d7a..8a88a8e9b 100644
--- a/main/settings/src/test/scala/ScopedKeySpec.scala
+++ b/main/settings/src/test/scala/ScopedKeySpec.scala
@@ -3,6 +3,7 @@ package sbt
 import org.specs2._
 import Scope.{ ThisScope, GlobalScope, parseScopedKey }
 import java.net.URI
+import sbt.internal.util.AttributeKey
 
 /**
  * http://www.scala-sbt.org/0.13/tutorial/Scopes.html
diff --git a/main/settings/src/test/scala/UsageTest.scala b/main/settings/src/test/scala/UsageTest.scala
index b6c3a9ca9..a94fc6a90 100644
--- a/main/settings/src/test/scala/UsageTest.scala
+++ b/main/settings/src/test/scala/UsageTest.scala
@@ -1,7 +1,8 @@
 package sbt
 package std
 
-import complete.{ DefaultParsers, Parsers }
+import sbt.internal.util.complete
+import sbt.internal.util.complete.{ DefaultParsers, Parsers }
 
 /*object UseTask
 {
diff --git a/main/src/main/scala/sbt/APIMappings.scala b/main/src/main/scala/sbt/APIMappings.scala
index a51d81cc9..f807684b0 100644
--- a/main/src/main/scala/sbt/APIMappings.scala
+++ b/main/src/main/scala/sbt/APIMappings.scala
@@ -3,7 +3,11 @@ package sbt
 import java.io.File
 import java.net.{ MalformedURLException, URL }
 
-import sbt.mavenint.SbtPomExtraProperties
+import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties
+import sbt.librarymanagement.ModuleID
+
+import sbt.internal.util.Attributed
+import sbt.util.Logger
 
 private[sbt] object APIMappings {
   def extract(cp: Seq[Attributed[File]], log: Logger): Seq[(File, URL)] =
@@ -32,4 +36,4 @@ private[sbt] object APIMappings {
     case None    => attr
     case Some(u) => attr.put(Keys.entryApiURL, u)
   }
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/Act.scala b/main/src/main/scala/sbt/Act.scala
index 3606de881..a5d09921c 100644
--- a/main/src/main/scala/sbt/Act.scala
+++ b/main/src/main/scala/sbt/Act.scala
@@ -6,12 +6,13 @@ package sbt
 import Def.{ showRelativeKey, ScopedKey }
 import Project.showContextKey
 import Keys.{ sessionSettings, thisProject }
-import complete.{ DefaultParsers, Parser }
+import sbt.internal.util.complete.{ DefaultParsers, Parser }
 import Aggregation.{ KeyValue, Values }
 import DefaultParsers._
-import Types.idFun
+import sbt.internal.util.Types.idFun
 import java.net.URI
 import CommandStrings.{ MultiTaskCommand, ShowCommand }
+import sbt.internal.util.{ AttributeEntry, AttributeKey, AttributeMap, IMap, Settings, Show, Util }
 
 final class ParsedKey(val key: ScopedKey[_], val mask: ScopeMask)
 
@@ -300,4 +301,4 @@ object Act {
   final object Omitted extends ParsedAxis[Nothing]
   final class ParsedValue[T](val value: T) extends ParsedAxis[T]
   def value[T](t: Parser[T]): Parser[ParsedAxis[T]] = t map { v => new ParsedValue(v) }
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/AddSettings.scala b/main/src/main/scala/sbt/AddSettings.scala
index 5ecb34195..3ef8c1934 100644
--- a/main/src/main/scala/sbt/AddSettings.scala
+++ b/main/src/main/scala/sbt/AddSettings.scala
@@ -1,6 +1,6 @@
 package sbt
 
-import Types.const
+import sbt.internal.util.Types.const
 import java.io.File
 
 /**
diff --git a/main/src/main/scala/sbt/Aggregation.scala b/main/src/main/scala/sbt/Aggregation.scala
index d251b375f..45bf254bb 100644
--- a/main/src/main/scala/sbt/Aggregation.scala
+++ b/main/src/main/scala/sbt/Aggregation.scala
@@ -5,7 +5,9 @@ package sbt
 
 import Def.ScopedKey
 import Keys.{ aggregate, showSuccess, showTiming, timingFormat }
-import sbt.complete.Parser
+import sbt.internal.util.complete.Parser
+import sbt.internal.util.{ Dag, HList, Relation, Settings, Show, Util }
+import sbt.util.Logger
 import java.net.URI
 import Parser._
 import collection.mutable
diff --git a/main/src/main/scala/sbt/Build.scala b/main/src/main/scala/sbt/Build.scala
index fcb78074f..57f65d4fc 100644
--- a/main/src/main/scala/sbt/Build.scala
+++ b/main/src/main/scala/sbt/Build.scala
@@ -6,6 +6,8 @@ package sbt
 import java.io.File
 import Keys.{ name, organization, thisProject, autoGeneratedProject }
 import Def.{ ScopedKey, Setting }
+import sbt.io.Hash
+import sbt.internal.util.Attributed
 
 // name is more like BuildDefinition, but that is too long
 trait Build {
diff --git a/main/src/main/scala/sbt/BuildDependencies.scala b/main/src/main/scala/sbt/BuildDependencies.scala
index d32f0a990..2d71e1788 100644
--- a/main/src/main/scala/sbt/BuildDependencies.scala
+++ b/main/src/main/scala/sbt/BuildDependencies.scala
@@ -1,6 +1,7 @@
 package sbt
 
-import Types.idFun
+import sbt.internal.util.Types.idFun
+import sbt.internal.util.Dag
 import BuildDependencies._
 
 final class BuildDependencies private (val classpath: DependencyMap[ClasspathDep[ProjectRef]], val aggregate: DependencyMap[ProjectRef]) {
@@ -26,4 +27,4 @@ object BuildDependencies {
       (ref, sorted dropRight 1)
     }
   val getID: ClasspathDep[ProjectRef] => ProjectRef = _.project
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/BuildLoader.scala b/main/src/main/scala/sbt/BuildLoader.scala
index f4cd55255..92ad3ba2b 100644
--- a/main/src/main/scala/sbt/BuildLoader.scala
+++ b/main/src/main/scala/sbt/BuildLoader.scala
@@ -6,8 +6,10 @@ package sbt
 import java.io.File
 import java.net.URI
 import BuildLoader._
-import Alternatives._
-import Types.{ const, idFun }
+import sbt.internal.io.Alternatives._
+import sbt.internal.util.Types.{ const, idFun }
+import sbt.util.Logger
+import sbt.librarymanagement.ModuleID
 
 final class MultiHandler[S, T](builtIn: S => Option[T], root: Option[S => Option[T]], nonRoots: List[(URI, S => Option[T])], getURI: S => URI, log: S => Logger) {
   def applyFun: S => Option[T] = apply
diff --git a/main/src/main/scala/sbt/BuildPaths.scala b/main/src/main/scala/sbt/BuildPaths.scala
index eb462f20f..1070ac57f 100644
--- a/main/src/main/scala/sbt/BuildPaths.scala
+++ b/main/src/main/scala/sbt/BuildPaths.scala
@@ -7,6 +7,10 @@ import java.io.File
 import java.net.URI
 import KeyRanks.DSetting
 
+import sbt.io.{ GlobFilter, Path }
+import sbt.internal.util.AttributeKey
+import sbt.util.Logger
+
 object BuildPaths {
   val globalBaseDirectory = AttributeKey[File]("global-base-directory", "The base directory for global sbt configuration and staging.", DSetting)
   val globalPluginsDirectory = AttributeKey[File]("global-plugins-directory", "The base directory for global sbt plugins.", DSetting)
@@ -57,7 +61,7 @@ object BuildPaths {
   def defaultGlobalBase = Path.userHome / ConfigDirectoryName
 
   private[this] def binarySbtVersion(state: State): String =
-    sbt.cross.CrossVersionUtil.binarySbtVersion(state.configuration.provider.id.version)
+    sbt.internal.librarymanagement.cross.CrossVersionUtil.binarySbtVersion(state.configuration.provider.id.version)
   private[this] def defaultStaging(globalBase: File) = globalBase / "staging"
   private[this] def defaultGlobalPlugins(globalBase: File) = globalBase / PluginsDirectoryName
   private[this] def defaultDependencyBase(globalBase: File) = globalBase / "dependency"
diff --git a/main/src/main/scala/sbt/BuildStructure.scala b/main/src/main/scala/sbt/BuildStructure.scala
index a06fe97a3..97419b376 100644
--- a/main/src/main/scala/sbt/BuildStructure.scala
+++ b/main/src/main/scala/sbt/BuildStructure.scala
@@ -6,11 +6,13 @@ package sbt
 import java.io.File
 import java.net.URI
 import Def.{ displayFull, ScopedKey, ScopeLocal, Setting }
-import Attributed.data
 import BuildPaths.outputDirectory
 import Scope.GlobalScope
 import BuildStreams.Streams
-import Path._
+import sbt.io.Path._
+import sbt.internal.util.{ Attributed, AttributeEntry, AttributeKey, AttributeMap, Settings }
+import sbt.internal.util.Attributed.data
+import sbt.util.Logger
 
 final class BuildStructure(val units: Map[URI, LoadedBuildUnit], val root: URI, val settings: Seq[Setting[_]], val data: Settings[Scope], val index: StructureIndex, val streams: State => Streams, val delegates: Scope => Seq[Scope], val scopeLocal: ScopeLocal) {
   val rootProject: URI => String = Load getRootProject units
@@ -250,4 +252,4 @@ object BuildStreams {
     refTarget(GlobalScope.copy(project = Select(ref)), fallbackBase, data)
   def refTarget(scope: Scope, fallbackBase: File, data: Settings[Scope]): File =
     (Keys.target in scope get data getOrElse outputDirectory(fallbackBase).asFile) / StreamsDirectory
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/BuildUtil.scala b/main/src/main/scala/sbt/BuildUtil.scala
index 1dcd773f1..85514aecd 100644
--- a/main/src/main/scala/sbt/BuildUtil.scala
+++ b/main/src/main/scala/sbt/BuildUtil.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.internal.util.{ Relation, Settings, Dag }
+
 import java.net.URI
 
 final class BuildUtil[Proj](
diff --git a/main/src/main/scala/sbt/CommandStrings.scala b/main/src/main/scala/sbt/CommandStrings.scala
index cb21d3053..7bbda44d1 100644
--- a/main/src/main/scala/sbt/CommandStrings.scala
+++ b/main/src/main/scala/sbt/CommandStrings.scala
@@ -3,6 +3,8 @@
  */
 package sbt
 
+import sbt.io.Path
+
 object CommandStrings {
   /** The prefix used to identify a request to execute the remaining input on source changes.*/
   val AboutCommand = "about"
diff --git a/main/src/main/scala/sbt/ConsoleProject.scala b/main/src/main/scala/sbt/ConsoleProject.scala
index a484d4e8f..33cb4c6e5 100644
--- a/main/src/main/scala/sbt/ConsoleProject.scala
+++ b/main/src/main/scala/sbt/ConsoleProject.scala
@@ -3,6 +3,7 @@
  */
 package sbt
 
+import sbt.util.Logger
 import java.io.File
 
 object ConsoleProject {
@@ -11,7 +12,8 @@ object ConsoleProject {
     val cpImports = new Imports(extracted, state)
     val bindings = ("currentState" -> state) :: ("extracted" -> extracted) :: ("cpHelpers" -> cpImports) :: Nil
     val unit = extracted.currentUnit
-    val compiler = Compiler.compilers(ClasspathOptions.repl)(state.configuration, log).scalac
+    // TODO: Fix this
+    val compiler: sbt.compiler.AnalyzingCompiler = ??? //Compiler.compilers(ClasspathOptions.repl)(state.configuration, log).scalac
     val imports = BuildUtil.getImports(unit.unit) ++ BuildUtil.importAll(bindings.map(_._1))
     val importString = imports.mkString("", ";\n", ";\n\n")
     val initCommands = importString + extra
diff --git a/main/src/main/scala/sbt/Cross.scala b/main/src/main/scala/sbt/Cross.scala
index 0a69895a8..bb1822580 100644
--- a/main/src/main/scala/sbt/Cross.scala
+++ b/main/src/main/scala/sbt/Cross.scala
@@ -4,13 +4,16 @@
 package sbt
 
 import Keys._
-import complete.{ DefaultParsers, Parser }
+import sbt.internal.util.complete.{ DefaultParsers, Parser }
+import sbt.internal.util.AttributeKey
 import DefaultParsers._
 import Def.{ ScopedKey, Setting }
 import Scope.GlobalScope
 import CommandStrings.{ CrossCommand, crossHelp, SwitchCommand, switchHelp }
 import java.io.File
 
+import sbt.io.IO
+
 object Cross {
   @deprecated("Moved to CommandStrings.Switch", "0.13.0")
   final val Switch = CommandStrings.SwitchCommand
@@ -123,4 +126,4 @@ object Cross {
   def requireSession[T](p: State => Parser[T]): State => Parser[T] = s =>
     if (s get sessionSettings isEmpty) failure("No project loaded") else p(s)
 
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala
index 9904ee22e..3f5e50b0f 100755
--- a/main/src/main/scala/sbt/Defaults.scala
+++ b/main/src/main/scala/sbt/Defaults.scala
@@ -4,23 +4,31 @@
 package sbt
 
 import scala.concurrent.duration.{ FiniteDuration, Duration }
-import Attributed.data
+import sbt.internal.util.Attributed
+import sbt.internal.util.Attributed.data
 import Scope.{ fillTaskAxis, GlobalScope, ThisScope }
 import sbt.Compiler.InputsWithPrevious
-import sbt.mavenint.{ PomExtraDependencyAttributes, SbtPomExtraProperties }
+import sbt.internal.librarymanagement.mavenint.{ PomExtraDependencyAttributes, SbtPomExtraProperties }
 import xsbt.api.Discovery
 import xsbti.compile.CompileOrder
 import Project.{ inConfig, inScope, inTask, richInitialize, richInitializeTask, richTaskSessionVar }
 import Def.{ Initialize, ScopedKey, Setting, SettingsDefinition }
-import Artifact.{ DocClassifier, SourceClassifier }
-import Configurations.{ Compile, CompilerPlugin, IntegrationTest, names, Provided, Runtime, Test }
-import CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion }
-import complete._
+import sbt.internal.librarymanagement.{ CustomPomParser, DependencyFilter }
+import sbt.librarymanagement.Artifact.{ DocClassifier, SourceClassifier }
+import sbt.librarymanagement.{ Configuration, Configurations, ConflictManager, CrossVersion, MavenRepository, Resolver, ScalaArtifacts, UpdateOptions }
+import sbt.librarymanagement.Configurations.{ Compile, CompilerPlugin, IntegrationTest, names, Provided, Runtime, Test }
+import sbt.librarymanagement.CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion }
+import sbt.internal.util.complete._
 import std.TaskExtra._
 import sbt.inc.{ Analysis, FileValueCache, IncOptions, Locate }
-import sbt.compiler.{ MixedAnalyzingCompiler, AggressiveCompile }
+import sbt.compiler.MixedAnalyzingCompiler
 import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint }
 
+import sbt.librarymanagement._
+import sbt.internal.librarymanagement._
+import sbt.internal.util._
+import sbt.util.Level
+
 import sys.error
 import scala.xml.NodeSeq
 import org.apache.ivy.core.module.{ descriptor, id }
@@ -29,10 +37,15 @@ import java.io.{ File, PrintWriter }
 import java.net.{ URI, URL, MalformedURLException }
 import java.util.concurrent.{ TimeUnit, Callable }
 import sbinary.DefaultProtocol.StringFormat
-import Cache.seqFormat
+import sbt.internal.util.Cache.seqFormat
+import sbt.util.Logger
 import CommandStrings.ExportStream
 
-import Types._
+import sbt.internal.util.Types._
+
+import sbt.internal.io.WatchState
+import sbt.io.{ AllPassFilter, FileFilter, GlobFilter, HiddenFileFilter, IO, NameFilter, NothingFilter, Path, PathFinder }
+
 import Path._
 import Keys._
 
@@ -225,7 +238,7 @@ object Defaults extends BuildCommon {
 
   def compileBase = inTask(console)(compilersSetting :: Nil) ++ compileBaseGlobal ++ Seq(
     incOptions := incOptions.value.withNewClassfileManager(
-      sbt.inc.ClassfileManager.transactional(crossTarget.value / "classes.bak", sbt.Logger.Null)),
+      sbt.inc.ClassfileManager.transactional(crossTarget.value / "classes.bak", sbt.util.Logger.Null)),
     scalaInstance <<= scalaInstanceTask,
     crossVersion := (if (crossPaths.value) CrossVersion.binary else CrossVersion.Disabled),
     crossTarget := makeCrossTarget(target.value, scalaBinaryVersion.value, sbtBinaryVersion.value, sbtPlugin.value, crossPaths.value),
@@ -261,7 +274,8 @@ object Defaults extends BuildCommon {
       if (plugin) scalaBase / ("sbt-" + sbtv) else scalaBase
     }
 
-  def compilersSetting = compilers := Compiler.compilers(scalaInstance.value, classpathOptions.value, javaHome.value, ivyConfiguration.value)(appConfiguration.value, streams.value.log)
+  // TODO: Fix source module
+  def compilersSetting = compilers := Compiler.compilers(scalaInstance.value, classpathOptions.value, javaHome.value, ivyConfiguration.value, ???)(appConfiguration.value, streams.value.log)
 
   lazy val configTasks = docTaskSettings(doc) ++ inTask(compile)(compileInputsSettings) ++ configGlobal ++ compileAnalysisSettings ++ Seq(
     compile <<= compileTask,
@@ -279,7 +293,7 @@ object Defaults extends BuildCommon {
     compileIncSetup <<= compileIncSetupTask,
     console <<= consoleTask,
     consoleQuick <<= consoleQuickTask,
-    discoveredMainClasses <<= compile map discoverMainClasses storeAs discoveredMainClasses triggeredBy compile,
+    discoveredMainClasses <<= compile map discoverMainClasses storeAs discoveredMainClasses xtriggeredBy compile,
     definedSbtPlugins <<= discoverPlugins,
     discoveredSbtPlugins <<= discoverSbtPluginNames,
     inTask(run)(runnerTask :: Nil).head,
@@ -390,7 +404,7 @@ object Defaults extends BuildCommon {
     val libraryJar = file(ScalaArtifacts.LibraryID)
     val compilerJar = file(ScalaArtifacts.CompilerID)
     val otherJars = allFiles.filterNot(x => x == libraryJar || x == compilerJar)
-    ScalaInstance(scalaVersion.value, libraryJar, compilerJar, otherJars: _*)(makeClassLoader(state.value))
+    new ScalaInstance(scalaVersion.value, makeClassLoader(state.value)(libraryJar :: compilerJar :: otherJars.toList), libraryJar, compilerJar, otherJars.toArray, None)
   }
   def scalaInstanceFromHome(dir: File): Initialize[Task[ScalaInstance]] = Def.task {
     ScalaInstance(dir)(makeClassLoader(state.value))
@@ -716,7 +730,7 @@ object Defaults extends BuildCommon {
 
   def doClean(clean: Seq[File], preserve: Seq[File]): Unit =
     IO.withTemporaryDirectory { temp =>
-      val (dirs, files) = preserve.filter(_.exists).flatMap(_.***.get).partition(_.isDirectory)
+      val (dirs, files) = preserve.filter(_.exists).flatMap(_.allPaths.get).partition(_.isDirectory)
       val mappings = files.zipWithIndex map { case (f, i) => (f, new File(temp, i.toHexString)) }
       IO.move(mappings)
       IO.delete(clean)
@@ -810,7 +824,7 @@ object Defaults extends BuildCommon {
     (compilers in task, classpath in task, scalacOptions in task, initialCommands in task, cleanupCommands in task, taskTemporaryDirectory in task, scalaInstance in task, streams) map {
       (cs, cp, options, initCommands, cleanup, temp, si, s) =>
         val cpFiles = data(cp)
-        val fullcp = (cpFiles ++ si.jars).distinct
+        val fullcp = (cpFiles ++ si.allJars).distinct
         val loader = sbt.classpath.ClasspathUtilities.makeLoader(fullcp, si, IO.createUniqueDirectory(temp))
         val compiler = cs.scalac.onArgs(exported(s, "scala"))
         (new Console(compiler))(cpFiles, options, loader, initCommands, cleanup)()(s.log).foreach(msg => sys.error(msg))
@@ -1370,7 +1384,7 @@ object Classpaths {
         case _                                         => Nil
       }
     val subScalaJars: String => Seq[File] = Defaults.unmanagedScalaInstanceOnly.value match {
-      case Some(si) => subUnmanaged(si.version, si.jars)
+      case Some(si) => subUnmanaged(si.version, si.allJars)
       case None     => sv => if (scalaProvider.version == sv) scalaProvider.jars else Nil
     }
     val transform: UpdateReport => UpdateReport = r => substituteScalaFiles(scalaOrganization.value, r)(subScalaJars)
@@ -1746,7 +1760,7 @@ object Classpaths {
 
   @deprecated("Directly provide the jar files per Scala version.", "0.13.0")
   def substituteScalaFiles(scalaInstance: ScalaInstance, scalaOrg: String, report: UpdateReport): UpdateReport =
-    substituteScalaFiles(scalaOrg, report)(const(scalaInstance.jars))
+    substituteScalaFiles(scalaOrg, report)(const(scalaInstance.allJars))
 
   def substituteScalaFiles(scalaOrg: String, report: UpdateReport)(scalaJars: String => Seq[File]): UpdateReport =
     report.substitute { (configuration, module, arts) =>
diff --git a/main/src/main/scala/sbt/EvaluateConfigurations.scala b/main/src/main/scala/sbt/EvaluateConfigurations.scala
index 83f56195b..c9ab5d275 100644
--- a/main/src/main/scala/sbt/EvaluateConfigurations.scala
+++ b/main/src/main/scala/sbt/EvaluateConfigurations.scala
@@ -3,6 +3,8 @@
  */
 package sbt
 
+import sbt.internal.util.{ complete, AttributeEntry, AttributeKey, LineRange, MessageOnlyException, RangePosition, Settings }
+
 import java.io.File
 import compiler.{ Eval, EvalImports }
 import complete.DefaultParsers.validID
@@ -12,6 +14,8 @@ import sbt.internals.parser.SbtParser
 
 import scala.annotation.tailrec
 
+import sbt.io.IO
+
 /**
  *  This file is responsible for compiling the .sbt files used to configure sbt builds.
  *
@@ -311,4 +315,4 @@ object Index {
   private[this] def update(map: TriggerMap, base: Task[_], tasksOpt: Option[Seq[Task[_]]]): Unit =
     for (tasks <- tasksOpt; task <- tasks)
       map(task) = base +: map.getOrElse(task, Nil)
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/EvaluateTask.scala b/main/src/main/scala/sbt/EvaluateTask.scala
index 5356fe635..2374bb893 100644
--- a/main/src/main/scala/sbt/EvaluateTask.scala
+++ b/main/src/main/scala/sbt/EvaluateTask.scala
@@ -3,6 +3,10 @@
  */
 package sbt
 
+import sbt.internal.util.{ ErrorHandling, RMap, Show, Signals, Types }
+import sbt.util.Logger
+import sbt.librarymanagement.{ Resolver, UpdateReport }
+
 import scala.concurrent.duration.Duration
 import java.io.File
 import Def.{ displayFull, dummyState, ScopedKey, Setting }
@@ -10,7 +14,8 @@ import Keys.{ streams, Streams, TaskStreams }
 import Keys.{ dummyRoots, dummyStreamsManager, executionRoots, pluginData, streamsManager, taskDefinitionKey, transformState }
 import Project.richInitializeTask
 import Scope.{ GlobalScope, ThisScope }
-import Types.const
+import sbt.internal.util.Types.const
+import sbt.internal.util.{ Attributed, HList }
 import scala.Console.RED
 import std.Transform.{ DummyTaskMap, TaskAndValue }
 import TaskName._
diff --git a/main/src/main/scala/sbt/Extracted.scala b/main/src/main/scala/sbt/Extracted.scala
index 0ac639765..7661de91f 100644
--- a/main/src/main/scala/sbt/Extracted.scala
+++ b/main/src/main/scala/sbt/Extracted.scala
@@ -3,7 +3,8 @@ package sbt
 import Project._
 import Scope.GlobalScope
 import Def.{ ScopedKey, Setting }
-import sbt.complete.Parser
+import sbt.internal.util.complete.Parser
+import sbt.internal.util.{ AttributeKey, Show }
 import std.Transform.DummyTaskMap
 
 final case class Extracted(structure: BuildStructure, session: SessionSettings, currentRef: ProjectRef)(implicit val showKey: Show[ScopedKey[_]]) {
diff --git a/main/src/main/scala/sbt/GCUtil.scala b/main/src/main/scala/sbt/GCUtil.scala
index cc223fd54..c25668a44 100644
--- a/main/src/main/scala/sbt/GCUtil.scala
+++ b/main/src/main/scala/sbt/GCUtil.scala
@@ -3,6 +3,7 @@ package sbt
 import java.util.concurrent.atomic.AtomicLong
 import scala.concurrent.duration._
 import scala.util.control.NonFatal
+import sbt.util.Logger
 
 private[sbt] object GCUtil {
   // Returns the default force garbage collection flag,
diff --git a/main/src/main/scala/sbt/GlobalPlugin.scala b/main/src/main/scala/sbt/GlobalPlugin.scala
index 88b767b94..dc97fdfa6 100644
--- a/main/src/main/scala/sbt/GlobalPlugin.scala
+++ b/main/src/main/scala/sbt/GlobalPlugin.scala
@@ -1,5 +1,8 @@
 package sbt
 
+import sbt.librarymanagement.{ Configuration, Configurations, ModuleID, Resolver, SbtArtifacts, UpdateReport }
+import sbt.internal.util.Attributed
+
 import Load.{ BuildStructure => _, _ }
 import Def.{ ScopedKey, Setting }
 import Scoped._
diff --git a/main/src/main/scala/sbt/Inspect.scala b/main/src/main/scala/sbt/Inspect.scala
index d4ef2bd44..6413ce2cb 100644
--- a/main/src/main/scala/sbt/Inspect.scala
+++ b/main/src/main/scala/sbt/Inspect.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.internal.util.{ AttributeKey, complete, Types }
+
 import complete.{ DefaultParsers, Parser }
 import DefaultParsers._
 import Def.ScopedKey
diff --git a/main/src/main/scala/sbt/IvyConsole.scala b/main/src/main/scala/sbt/IvyConsole.scala
index 241475f15..0feb68156 100644
--- a/main/src/main/scala/sbt/IvyConsole.scala
+++ b/main/src/main/scala/sbt/IvyConsole.scala
@@ -3,12 +3,19 @@
  */
 package sbt
 
+import sbt.internal.util.Attributed
+import sbt.util.{ Level, Logger }
+
+import sbt.librarymanagement.{ Configurations, CrossVersion, MavenRepository, ModuleID, Resolver }
+
 import java.io.File
 import Attributed.blankSeq
 import Configurations.Compile
 import Def.Setting
 import Keys._
 
+import sbt.io.IO
+
 object IvyConsole {
   final val Name = "ivy-console"
   lazy val command =
diff --git a/main/src/main/scala/sbt/KeyIndex.scala b/main/src/main/scala/sbt/KeyIndex.scala
index 83723a477..39d3eb3bb 100644
--- a/main/src/main/scala/sbt/KeyIndex.scala
+++ b/main/src/main/scala/sbt/KeyIndex.scala
@@ -3,10 +3,13 @@
  */
 package sbt
 
+import sbt.internal.util.Relation
+
 import java.net.URI
 import Def.ScopedKey
-import complete.DefaultParsers.validID
-import Types.{ idFun, some }
+import sbt.internal.util.complete.DefaultParsers.validID
+import sbt.internal.util.Types.{ idFun, some }
+import sbt.internal.util.AttributeKey
 
 object KeyIndex {
   def empty: ExtendableKeyIndex = new KeyIndex0(emptyBuildIndex)
diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala
index b5f1d96de..367792b8c 100644
--- a/main/src/main/scala/sbt/Keys.scala
+++ b/main/src/main/scala/sbt/Keys.scala
@@ -7,7 +7,7 @@ import java.io.File
 import java.net.URL
 import scala.concurrent.duration.{ FiniteDuration, Duration }
 import Def.ScopedKey
-import complete._
+import sbt.internal.util.complete._
 import inc.Analysis
 import inc.Locate.DefinesClass
 import sbt.compiler.MixedAnalyzingCompiler
@@ -17,10 +17,53 @@ import scala.xml.{ Node => XNode, NodeSeq }
 import org.apache.ivy.core.module.{ descriptor, id }
 import descriptor.ModuleDescriptor, id.ModuleRevisionId
 import testing.Framework
-import Configurations.CompilerPlugin
-import Types.Id
+import sbt.internal.util.Types.Id
 import KeyRanks._
 
+import sbt.io.FileFilter
+import sbt.internal.io.WatchState
+import sbt.internal.util.AttributeKey
+
+import sbt.librarymanagement.Configurations.CompilerPlugin
+import sbt.librarymanagement.{
+  Artifact,
+  Configuration,
+  ConflictManager,
+  ConflictWarning,
+  Credentials,
+  CrossVersion,
+  Developer,
+  EvictionWarning,
+  EvictionWarningOptions,
+  IvyScala,
+  MavenRepository,
+  ModuleConfiguration,
+  ModuleID,
+  ModuleInfo,
+  Resolver,
+  ScalaVersion,
+  ScmInfo,
+  UpdateOptions,
+  UpdateReport
+}
+import sbt.internal.librarymanagement.{
+  DeliverConfiguration,
+  GetClassifiersModule,
+  IvyConfiguration,
+  IvyPaths,
+  IvySbt,
+  MakePomConfiguration,
+  ModuleSettings,
+  PublishConfiguration,
+  RetrieveConfiguration,
+  SbtExclusionRule,
+  UnresolvedWarningConfiguration,
+  UpdateConfiguration,
+  UpdateLogging
+}
+import sbt.util.{ AbstractLogger, Level, Logger }
+import sbt.internal.util.SourcePosition
+
 object Keys {
   val TraceValues = "-1 to disable, 0 for up to the first sbt frame, or a positive number to set the maximum number of frames shown."
 
diff --git a/main/src/main/scala/sbt/Load.scala b/main/src/main/scala/sbt/Load.scala
index 3f41f5546..880a7e76c 100755
--- a/main/src/main/scala/sbt/Load.scala
+++ b/main/src/main/scala/sbt/Load.scala
@@ -3,6 +3,9 @@
  */
 package sbt
 
+import sbt.internal.util.{ Settings, Show, ~> }
+import sbt.librarymanagement.{ Configuration, Configurations }
+
 import java.io.File
 import java.net.{ URI, URL }
 import compiler.{ Eval, EvalImports }
@@ -16,12 +19,16 @@ import Def.{ isDummy, ScopedKey, ScopeLocal, Setting }
 import Keys.{ appConfiguration, baseDirectory, configuration, fullResolvers, fullClasspath, pluginData, streams, thisProject, thisProjectRef, update }
 import Keys.{ exportedProducts, loadedBuild, onLoadMessage, resolvedScoped, sbtPlugin, scalacOptions, taskDefinitionKey }
 import tools.nsc.reporters.ConsoleReporter
-import Attributed.data
+import sbt.internal.util.Attributed
+import sbt.internal.util.Attributed.data
 import Scope.{ GlobalScope, ThisScope }
-import Types.const
+import sbt.internal.util.Types.const
 import BuildPaths._
 import BuildStreams._
 import Locate.DefinesClass
+import sbt.io.{ GlobFilter, IO, Path }
+import sbt.internal.io.Alternatives
+import sbt.util.Logger
 
 object Load {
   // note that there is State passed in but not pulled out
@@ -44,7 +51,8 @@ object Load {
       val stagingDirectory = getStagingDirectory(state, globalBase).getCanonicalFile
       val loader = getClass.getClassLoader
       val classpath = Attributed.blankSeq(provider.mainClasspath ++ scalaProvider.jars)
-      val compilers = Compiler.compilers(ClasspathOptions.boot)(state.configuration, log)
+      // TODO: Fix this
+      val compilers = ??? //Compiler.compilers(ClasspathOptions.boot)(state.configuration, log)
       val evalPluginDef = EvaluateTask.evalPluginDef(log) _
       val delegates = defaultDelegates
       val initialID = baseDirectory.getName
@@ -259,7 +267,7 @@ object Load {
     if (keepSet.nonEmpty) {
       def keepFile(f: File) = keepSet(f.getCanonicalPath)
       import Path._
-      val existing = (baseTarget.***.get).filterNot(_.isDirectory)
+      val existing = (baseTarget.allPaths.get).filterNot(_.isDirectory)
       val toDelete = existing.filterNot(keepFile)
       if (toDelete.nonEmpty) {
         IO.delete(toDelete)
diff --git a/main/src/main/scala/sbt/LogManager.scala b/main/src/main/scala/sbt/LogManager.scala
index e5c8befa2..baf260f2e 100644
--- a/main/src/main/scala/sbt/LogManager.scala
+++ b/main/src/main/scala/sbt/LogManager.scala
@@ -9,10 +9,12 @@ import LogManager._
 import std.Transform
 import Def.ScopedKey
 import Scope.GlobalScope
-import MainLogging._
 import BasicKeys.explicitGlobalLogLevels
 import Keys.{ logLevel, logManager, persistLogLevel, persistTraceLevel, sLog, state, traceLevel }
 import scala.Console.{ BLUE, RESET }
+import sbt.internal.util.{ AttributeKey, ConsoleOut, MultiLoggerConfig, Settings, SuppressedTraceContext }
+import sbt.internal.util.MainLogging._
+import sbt.util.{ AbstractLogger, Level, Logger }
 
 object LogManager {
   def construct(data: Settings[Scope], state: State) = (task: ScopedKey[_], to: PrintWriter) =>
diff --git a/main/src/main/scala/sbt/Main.scala b/main/src/main/scala/sbt/Main.scala
index 2686ce1ef..153d223fd 100644
--- a/main/src/main/scala/sbt/Main.scala
+++ b/main/src/main/scala/sbt/Main.scala
@@ -3,6 +3,9 @@
  */
 package sbt
 
+import sbt.internal.util.{ AttributeKey, AttributeMap, complete, ConsoleOut, GlobalLogging, LineRange, MainLogging, SimpleReader, Types }
+import sbt.util.{ Level, Logger }
+
 import complete.{ DefaultParsers, Parser }
 import compiler.{ CompilerCache, EvalImports }
 import Types.{ const, idFun }
@@ -10,7 +13,8 @@ import Aggregation.AnyKeys
 import Project.LoadAction
 
 import scala.annotation.tailrec
-import Path._
+import sbt.io.IO
+import sbt.io.Path._
 import StandardMain._
 
 import java.io.File
diff --git a/main/src/main/scala/sbt/Opts.scala b/main/src/main/scala/sbt/Opts.scala
index 940bc5a60..4f5e1e19d 100644
--- a/main/src/main/scala/sbt/Opts.scala
+++ b/main/src/main/scala/sbt/Opts.scala
@@ -3,9 +3,13 @@
  */
 package sbt
 
+import sbt.librarymanagement.{ Credentials, MavenRepository, Resolver }
+
 import java.io.File
 import java.net.URL
 
+import sbt.io.Path
+
 /** Options for well-known tasks. */
 object Opts {
   object compile {
diff --git a/main/src/main/scala/sbt/Output.scala b/main/src/main/scala/sbt/Output.scala
index ce9f49a65..56c77cd61 100644
--- a/main/src/main/scala/sbt/Output.scala
+++ b/main/src/main/scala/sbt/Output.scala
@@ -3,6 +3,8 @@
  */
 package sbt
 
+import sbt.internal.util.{ Show, Types }
+
 import java.util.regex.Pattern
 import java.io.File
 import Keys.{ Streams, TaskStreams }
@@ -12,6 +14,8 @@ import Types.idFun
 import Highlight.{ bold, showMatches }
 import annotation.tailrec
 
+import sbt.io.IO
+
 object Output {
   final val DefaultTail = "> "
 
diff --git a/main/src/main/scala/sbt/PluginDiscovery.scala b/main/src/main/scala/sbt/PluginDiscovery.scala
index ad453d50c..fd79b1118 100644
--- a/main/src/main/scala/sbt/PluginDiscovery.scala
+++ b/main/src/main/scala/sbt/PluginDiscovery.scala
@@ -1,11 +1,15 @@
 package sbt
 
+import sbt.internal.util.Attributed
+
 import java.io.File
 import java.net.URL
 import Attributed.data
 import Build.analyzed
 import xsbt.api.{ Discovered, Discovery }
 
+import sbt.io.IO
+
 object PluginDiscovery {
   /**
    * Relative paths of resources that list top-level modules that are available.
diff --git a/main/src/main/scala/sbt/PluginManagement.scala b/main/src/main/scala/sbt/PluginManagement.scala
index 12a80b689..faf2e81f4 100644
--- a/main/src/main/scala/sbt/PluginManagement.scala
+++ b/main/src/main/scala/sbt/PluginManagement.scala
@@ -3,6 +3,7 @@ package sbt
 import Keys.Classpath
 import Def.Setting
 import PluginManagement._
+import sbt.librarymanagement.ModuleID
 
 import java.net.{ URI, URL, URLClassLoader }
 
diff --git a/main/src/main/scala/sbt/Plugins.scala b/main/src/main/scala/sbt/Plugins.scala
index 543e1b800..a8975e138 100644
--- a/main/src/main/scala/sbt/Plugins.scala
+++ b/main/src/main/scala/sbt/Plugins.scala
@@ -5,11 +5,14 @@ TODO:
 - error message when a task doesn't exist that it would be provided by plugin x, enabled by natures y,z, blocked by a, b
 */
 
-import logic.{Atom, Clause, Clauses, Formula, Literal, Logic, Negated}
+import sbt.librarymanagement.Configuration
+
+import sbt.internal.util.logic.{Atom, Clause, Clauses, Formula, Literal, Logic, Negated}
 import Logic.{CyclicNegation, InitialContradictions, InitialOverlap, LogicException}
 import Def.Setting
 import Plugins._
 import annotation.tailrec
+import sbt.util.Logger
 
 /**
  * An AutoPlugin defines a group of settings and the conditions where the settings are automatically added to a build (called "activation").
@@ -334,7 +337,7 @@ ${listConflicts(conflicting)}""")
 
   private[sbt] def hasAutoImportGetter(ap: AutoPlugin, loader: ClassLoader): Boolean = {
     import reflect.runtime.{universe => ru}
-    import util.control.Exception.catching
+    import scala.util.control.Exception.catching
     val m = ru.runtimeMirror(loader)
     val im = m.reflect(ap)
     val hasGetterOpt = catching(classOf[ScalaReflectionException]) opt {
diff --git a/main/src/main/scala/sbt/PluginsDebug.scala b/main/src/main/scala/sbt/PluginsDebug.scala
index d15a238a8..69c513f68 100644
--- a/main/src/main/scala/sbt/PluginsDebug.scala
+++ b/main/src/main/scala/sbt/PluginsDebug.scala
@@ -1,5 +1,8 @@
 package sbt
 
+import sbt.internal.util.{ AttributeKey, Dag, Relation, Util }
+import sbt.util.Logger
+
   import Def.Setting
   import Plugins._
   import PluginsDebug._
@@ -372,4 +375,4 @@ private[sbt] object PluginsDebug {
     s"There is no way to enable plugin ${plugin.label}.  It (or its dependencies) requires plugin ${contradiction.label} to both be present and absent.  Please report the problem to the plugin's author."
   private[this] def pluginImpossibleN(plugin: AutoPlugin)(contradictions: List[AutoPlugin]): String =
     s"There is no way to enable plugin ${plugin.label}.  It (or its dependencies) requires these plugins to be both present and absent:\n\t${labels(contradictions).mkString("\n\t")}\nPlease report the problem to the plugin's author."
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/Project.scala b/main/src/main/scala/sbt/Project.scala
index 5ad063dc0..315a665af 100755
--- a/main/src/main/scala/sbt/Project.scala
+++ b/main/src/main/scala/sbt/Project.scala
@@ -10,8 +10,11 @@ import Project.{ Initialize => _, Setting => _, _ }
 import Keys.{ appConfiguration, stateBuildStructure, commands, configuration, historyPath, projectCommand, sessionSettings, shellPrompt, thisProject, thisProjectRef, watch }
 import Scope.{ GlobalScope, ThisScope }
 import Def.{ Flattened, Initialize, ScopedKey, Setting }
-import Types.{ const, idFun }
-import complete.DefaultParsers
+import sbt.internal.util.Types.{ const, idFun }
+import sbt.internal.util.complete.DefaultParsers
+import sbt.librarymanagement.Configuration
+
+import sbt.internal.util.{ AttributeKey, AttributeMap, Dag, Relation, Settings, Show, ~> }
 
 import language.experimental.macros
 
diff --git a/main/src/main/scala/sbt/ProjectNavigation.scala b/main/src/main/scala/sbt/ProjectNavigation.scala
index ef6ee2e2a..51806506b 100644
--- a/main/src/main/scala/sbt/ProjectNavigation.scala
+++ b/main/src/main/scala/sbt/ProjectNavigation.scala
@@ -3,6 +3,8 @@
  */
 package sbt
 
+import sbt.internal.util.complete
+
 import ProjectNavigation._
 import Project.updateCurrent
 import Keys.sessionSettings
@@ -66,4 +68,4 @@ final class ProjectNavigation(s: State) {
     }
   def rootRef = ProjectRef(currentRef.build, getRoot(currentRef.build))
   val command: Parser[() => State] = Command.applyEffect(parser)(apply)
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/Resolve.scala b/main/src/main/scala/sbt/Resolve.scala
index d396e1838..9d12f382c 100644
--- a/main/src/main/scala/sbt/Resolve.scala
+++ b/main/src/main/scala/sbt/Resolve.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.internal.util.AttributeKey
+
 import java.net.URI
 
 object Resolve {
diff --git a/main/src/main/scala/sbt/Resolvers.scala b/main/src/main/scala/sbt/Resolvers.scala
index 53e4def50..5382e7924 100644
--- a/main/src/main/scala/sbt/Resolvers.scala
+++ b/main/src/main/scala/sbt/Resolvers.scala
@@ -4,6 +4,10 @@
 
 package sbt
 
+import sbt.internal.librarymanagement.StringUtilities
+
+import sbt.io.{ Hash, IO }
+
 import java.io.File
 import java.net.URI
 
@@ -11,6 +15,8 @@ import BuildLoader.ResolveInfo
 import RichURI.fromURI
 import java.util.Locale
 
+import scala.sys.process.Process
+
 object Resolvers {
   type Resolver = BuildLoader.Resolver
 
diff --git a/main/src/main/scala/sbt/RichURI.scala b/main/src/main/scala/sbt/RichURI.scala
new file mode 100644
index 000000000..46a1c3729
--- /dev/null
+++ b/main/src/main/scala/sbt/RichURI.scala
@@ -0,0 +1,54 @@
+/* sbt -- Simple Build Tool
+ * Copyright 2011 Sanjin Sehic
+ */
+
+package sbt
+
+import java.net.URI
+
+/** Extends `URI` with additional convenience methods. */
+class RichURI(uri: URI) {
+  /**
+   * Provides a case-class-like `copy` method for URI.
+   * Note that this method simply passes the individual components of this URI to the URI constructor
+   * that accepts each component individually.  It is thus limited by the implementation restrictions of the relevant methods.
+   */
+  def copy(scheme: String = uri.getScheme, userInfo: String = uri.getUserInfo,
+    host: String = uri.getHost, port: Int = uri.getPort, path: String = uri.getPath,
+    query: String = uri.getQuery, fragment: String = uri.getFragment) =
+    new URI(scheme, userInfo, host, port, path, query, fragment)
+
+  /** Returns `true` if the fragment of the URI is defined. */
+  def hasFragment = uri.getFragment ne null
+
+  /** Returns a copy of the URI without the fragment. */
+  def withoutFragment =
+    if (hasFragment)
+      new URI(uri.getScheme, uri.getSchemeSpecificPart, null)
+    else
+      uri
+
+  /** Returns `true` if the scheme specific part of the URI is also a valid URI. */
+  def hasMarkerScheme = new URI(uri.getRawSchemeSpecificPart).getScheme ne null
+
+  /**
+   * Strips the wrapper scheme from this URI.
+   * If the URI has a fragment, the fragment is transferred to the wrapped URI.
+   * If this URI does not have a marker scheme, it is returned unchanged.
+   */
+  def withoutMarkerScheme =
+    {
+      if (hasMarkerScheme)
+        if (hasFragment)
+          new URI(uri.getRawSchemeSpecificPart + "#" + uri.getRawFragment)
+        else
+          new URI(uri.getRawSchemeSpecificPart)
+      else
+        uri
+    }
+}
+
+object RichURI {
+  /** Provides additional convenience methods for `uri`. */
+  implicit def fromURI(uri: URI): RichURI = new RichURI(uri)
+}
diff --git a/main/src/main/scala/sbt/ScopeFilter.scala b/main/src/main/scala/sbt/ScopeFilter.scala
index 34f67d471..dc1a33ff1 100644
--- a/main/src/main/scala/sbt/ScopeFilter.scala
+++ b/main/src/main/scala/sbt/ScopeFilter.scala
@@ -1,5 +1,9 @@
 package sbt
 
+import sbt.internal.util.{ AttributeKey, Dag, Types }
+
+import sbt.librarymanagement.Configuration
+
 import Types.{ const, idFun }
 import Def.Initialize
 import java.net.URI
@@ -213,4 +217,4 @@ object ScopeFilter {
     }
   }
 
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/ScopedKeyData.scala b/main/src/main/scala/sbt/ScopedKeyData.scala
index 6447db61e..76d20d04f 100644
--- a/main/src/main/scala/sbt/ScopedKeyData.scala
+++ b/main/src/main/scala/sbt/ScopedKeyData.scala
@@ -3,7 +3,7 @@ package sbt
 import Def.ScopedKey
 
 final case class ScopedKeyData[A](scoped: ScopedKey[A], value: Any) {
-  import Types.const
+  import sbt.internal.util.Types.const
   val key = scoped.key
   val scope = scoped.scope
   def typeName: String = fold(fmtMf("Task[%s]"), fmtMf("InputTask[%s]"), key.manifest.toString)
diff --git a/main/src/main/scala/sbt/Script.scala b/main/src/main/scala/sbt/Script.scala
index a59a0cbf0..baa34e63e 100644
--- a/main/src/main/scala/sbt/Script.scala
+++ b/main/src/main/scala/sbt/Script.scala
@@ -3,11 +3,17 @@
  */
 package sbt
 
+import sbt.librarymanagement.Configurations
+
+import sbt.util.Level
+
 import java.io.File
 import Keys._
 import EvaluateConfigurations.{ evaluateConfiguration => evaluate }
 import Configurations.Compile
 
+import sbt.io.{ Hash, IO }
+
 object Script {
   final val Name = "script"
   lazy val command =
diff --git a/main/src/main/scala/sbt/SessionSettings.scala b/main/src/main/scala/sbt/SessionSettings.scala
index b1ad2a930..771afe74e 100755
--- a/main/src/main/scala/sbt/SessionSettings.scala
+++ b/main/src/main/scala/sbt/SessionSettings.scala
@@ -3,6 +3,8 @@
  */
 package sbt
 
+import sbt.internal.util.{ complete, LineRange, RangePosition, Types }
+
 import java.io.File
 import java.net.URI
 import Def.{ ScopedKey, Setting }
@@ -12,6 +14,8 @@ import compiler.Eval
 import SessionSettings._
 import sbt.internals.parser.SbtRefactorings
 
+import sbt.io.IO
+
 /**
  * Represents (potentially) transient settings added into a build via commands/user.
  *
diff --git a/main/src/main/scala/sbt/SessionVar.scala b/main/src/main/scala/sbt/SessionVar.scala
index 1db5b4bc2..e7858c8eb 100644
--- a/main/src/main/scala/sbt/SessionVar.scala
+++ b/main/src/main/scala/sbt/SessionVar.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.internal.util.{ AttributeMap, IMap, Types }
+
 import Def.ScopedKey
 import Types.Id
 import Keys.sessionVars
diff --git a/main/src/main/scala/sbt/SettingCompletions.scala b/main/src/main/scala/sbt/SettingCompletions.scala
index 44c706785..f7c6655d7 100644
--- a/main/src/main/scala/sbt/SettingCompletions.scala
+++ b/main/src/main/scala/sbt/SettingCompletions.scala
@@ -1,5 +1,9 @@
 package sbt
 
+import sbt.internal.util.{ AttributeKey, complete, Relation, Settings, Show, Types, Util }
+
+import sbt.librarymanagement.Configuration
+
 import java.io.File
 import java.net.URI
 import Project._
diff --git a/main/src/main/scala/sbt/SettingGraph.scala b/main/src/main/scala/sbt/SettingGraph.scala
index 8a5d91b73..784b140ef 100644
--- a/main/src/main/scala/sbt/SettingGraph.scala
+++ b/main/src/main/scala/sbt/SettingGraph.scala
@@ -3,11 +3,15 @@
  */
 package sbt
 
+import sbt.internal.util.Show
+
 import java.net.URI
 import java.io.File
 import Def.{ compiled, flattenLocals, ScopedKey }
 import Predef.{ any2stringadd => _, _ }
 
+import sbt.io.IO
+
 object SettingGraph {
   def apply(structure: BuildStructure, basedir: File, scoped: ScopedKey[_], generation: Int)(implicit display: Show[ScopedKey[_]]): SettingGraph =
     {
@@ -57,7 +61,8 @@ object Graph {
   // [info]   +-quux
   def toAscii[A](top: A, children: A => Seq[A], display: A => String): String = {
     val defaultWidth = 40
-    val maxColumn = math.max(JLine.usingTerminal(_.getWidth), defaultWidth) - 8
+    // TODO: Fix JLine
+    val maxColumn = math.max( /*JLine.usingTerminal(_.getWidth)*/ 0, defaultWidth) - 8
     val twoSpaces = " " + " " // prevent accidentally being converted into a tab
     def limitLine(s: String): String =
       if (s.length > maxColumn) s.slice(0, maxColumn - 2) + ".."
diff --git a/main/src/main/scala/sbt/TaskTimings.scala b/main/src/main/scala/sbt/TaskTimings.scala
index 75be9d25d..dc2d01190 100644
--- a/main/src/main/scala/sbt/TaskTimings.scala
+++ b/main/src/main/scala/sbt/TaskTimings.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.internal.util.RMap
+
 import java.util.concurrent.ConcurrentHashMap
 import TaskName._
 
diff --git a/main/src/main/scala/sbt/dsl/package.scala b/main/src/main/scala/sbt/dsl/package.scala
index d3b553373..637f3528c 100644
--- a/main/src/main/scala/sbt/dsl/package.scala
+++ b/main/src/main/scala/sbt/dsl/package.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.librarymanagement.Configuration
+
 import internals.{
   DslEntry,
   DslConfigs,
@@ -12,4 +14,4 @@ package object dsl {
   def disablePlugins(ps: AutoPlugin*): DslEntry = DslDisablePlugins(ps)
   def configs(cs: Configuration*): DslEntry = DslConfigs(cs)
 
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/internals/DslAst.scala b/main/src/main/scala/sbt/internals/DslAst.scala
index 9cb5cfea7..d56641e16 100644
--- a/main/src/main/scala/sbt/internals/DslAst.scala
+++ b/main/src/main/scala/sbt/internals/DslAst.scala
@@ -1,6 +1,10 @@
 package sbt
 package internals
 
+import sbt.internal.util.RangePosition
+
+import sbt.librarymanagement.Configuration
+
 import Def._
 
 /** This reprsents a `Setting` expression configured by the sbt DSL. */
diff --git a/main/src/main/scala/sbt/internals/parser/SbtParser.scala b/main/src/main/scala/sbt/internals/parser/SbtParser.scala
index 8512cc33b..bf2289665 100644
--- a/main/src/main/scala/sbt/internals/parser/SbtParser.scala
+++ b/main/src/main/scala/sbt/internals/parser/SbtParser.scala
@@ -2,6 +2,8 @@ package sbt
 package internals
 package parser
 
+import sbt.internal.util.{ LineRange, MessageOnlyException }
+
 import java.io.File
 
 import sbt.internals.parser.SbtParser._
@@ -130,8 +132,8 @@ private[sbt] case class SbtParser(file: File, lines: Seq[String]) extends Parsed
      * @return originalStatement or originalStatement with missing bracket
      */
     def parseStatementAgain(t: Tree, originalStatement: String): String = {
-      val statement = util.Try(toolbox.parse(originalStatement)) match {
-        case util.Failure(th) =>
+      val statement = scala.util.Try(toolbox.parse(originalStatement)) match {
+        case scala.util.Failure(th) =>
           val missingText = findMissingText(content, t.pos.end, t.pos.line, fileName, th)
           originalStatement + missingText
         case _ =>
@@ -215,10 +217,10 @@ private[sbt] object MissingBracketHandler {
       case Some(index) =>
         val text = content.substring(positionEnd, index + 1)
         val textWithoutBracket = text.substring(0, text.length - 1)
-        util.Try(SbtParser(FAKE_FILE, textWithoutBracket.lines.toSeq)) match {
-          case util.Success(_) =>
+        scala.util.Try(SbtParser(FAKE_FILE, textWithoutBracket.lines.toSeq)) match {
+          case scala.util.Success(_) =>
             text
-          case util.Failure(th) =>
+          case scala.util.Failure(th) =>
             findMissingText(content, index + 1, positionLine, fileName, originalException)
         }
       case _ =>
diff --git a/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala b/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
index c1af6fffe..8f50a217f 100644
--- a/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/JUnitXmlReportPlugin.scala
@@ -1,6 +1,8 @@
 package sbt
 package plugins
 
+import sbt.librarymanagement.Configurations
+
 import Def.Setting
 import Keys._
 import Project.inConfig
@@ -26,4 +28,4 @@ object JUnitXmlReportPlugin extends AutoPlugin {
     Seq(
       testListeners += new JUnitXmlTestsListener(target.value.getAbsolutePath)
     )
-}
\ No newline at end of file
+}
diff --git a/main/src/main/scala/sbt/plugins/JvmPlugin.scala b/main/src/main/scala/sbt/plugins/JvmPlugin.scala
index e3c20056a..953bf2682 100644
--- a/main/src/main/scala/sbt/plugins/JvmPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/JvmPlugin.scala
@@ -1,6 +1,8 @@
 package sbt
 package plugins
 
+import sbt.librarymanagement.{ Configuration, Configurations }
+
 import Def.Setting
 
 /** A plugin representing the ability to build a JVM project.
@@ -34,4 +36,4 @@ object JvmPlugin extends AutoPlugin {
 
   override def projectConfigurations: Seq[Configuration] = 
     Configurations.default
-}
\ No newline at end of file
+}
diff --git a/main/src/test/scala/Delegates.scala b/main/src/test/scala/Delegates.scala
index 84ad678d1..4ae407b4d 100644
--- a/main/src/test/scala/Delegates.scala
+++ b/main/src/test/scala/Delegates.scala
@@ -1,7 +1,7 @@
 package sbt
 
 import Project._
-import Types.{ idFun, some }
+import sbt.internal.util.Types.{ idFun, some }
 import TestBuild._
 
 import java.io.File
@@ -70,4 +70,4 @@ object Delegates extends Properties("delegates") {
         }
       all(loop(s, Nil, modAndIdent).map(ds contains _: Prop): _*)
     }
-}
\ No newline at end of file
+}
diff --git a/main/src/test/scala/ParseKey.scala b/main/src/test/scala/ParseKey.scala
index d9607e2de..cef2894f8 100644
--- a/main/src/test/scala/ParseKey.scala
+++ b/main/src/test/scala/ParseKey.scala
@@ -3,7 +3,7 @@ package sbt
 import Def.{ displayFull, displayMasked, ScopedKey }
 import java.net.URI
 import TestBuild._
-import complete._
+import sbt.internal.util.complete._
 
 import org.scalacheck._
 import Gen._
diff --git a/main/src/test/scala/PluginCommandTest.scala b/main/src/test/scala/PluginCommandTest.scala
index 322bc08aa..93aa6bb6a 100644
--- a/main/src/test/scala/PluginCommandTest.scala
+++ b/main/src/test/scala/PluginCommandTest.scala
@@ -4,6 +4,8 @@ import java.io._
 
 import org.specs2.mutable.Specification
 
+import sbt.internal.util.{ AttributeEntry, AttributeMap, ConsoleOut, GlobalLogging, MainLogging, Settings }
+
 object PluginCommandTestPlugin0 extends AutoPlugin
 
 package subpackage {
diff --git a/main/src/test/scala/PluginsTest.scala b/main/src/test/scala/PluginsTest.scala
index b7c4bf4a1..3dc1df33b 100644
--- a/main/src/test/scala/PluginsTest.scala
+++ b/main/src/test/scala/PluginsTest.scala
@@ -3,6 +3,7 @@ package sbt
 import java.io.File
 import org.specs2._
 import mutable.Specification
+import sbt.util.Logger
 
 object PluginsTest extends Specification
 {
diff --git a/main/src/test/scala/TestBuild.scala b/main/src/test/scala/TestBuild.scala
index 8167eb8ed..b15bfda32 100644
--- a/main/src/test/scala/TestBuild.scala
+++ b/main/src/test/scala/TestBuild.scala
@@ -1,8 +1,9 @@
 package sbt
 
 import Def.{ ScopedKey, Setting }
-import Types.{ const, idFun, some }
-import complete.Parser
+import sbt.internal.util.{ AttributeKey, AttributeMap, Relation, Settings }
+import sbt.internal.util.Types.{ const, idFun, some }
+import sbt.internal.util.complete.Parser
 
 import java.io.File
 import java.net.URI
diff --git a/main/src/test/scala/sbt/internals/parser/EmbeddedXmlSpec.scala b/main/src/test/scala/sbt/internals/parser/EmbeddedXmlSpec.scala
index 2504ad01b..af50ed110 100644
--- a/main/src/test/scala/sbt/internals/parser/EmbeddedXmlSpec.scala
+++ b/main/src/test/scala/sbt/internals/parser/EmbeddedXmlSpec.scala
@@ -1,6 +1,6 @@
 package sbt.internals.parser
 
-import sbt.MessageOnlyException
+import sbt.internal.util.MessageOnlyException
 
 class EmbeddedXmlSpec extends CheckIfParsedSpec {
 
diff --git a/main/src/test/scala/sbt/internals/parser/ErrorSpec.scala b/main/src/test/scala/sbt/internals/parser/ErrorSpec.scala
index 9f9e10d9f..36aa3eb38 100644
--- a/main/src/test/scala/sbt/internals/parser/ErrorSpec.scala
+++ b/main/src/test/scala/sbt/internals/parser/ErrorSpec.scala
@@ -3,7 +3,8 @@ package sbt.internals.parser
 import java.io.File
 
 import org.specs2.ScalaCheck
-import sbt.{ EvaluateConfigurations, MessageOnlyException }
+import sbt.EvaluateConfigurations
+import sbt.internal.util.MessageOnlyException
 
 import scala.io.Source
 
diff --git a/main/src/test/scala/sbt/internals/parser/EvaluateConfigurationsOriginal.scala b/main/src/test/scala/sbt/internals/parser/EvaluateConfigurationsOriginal.scala
index 71580529f..d884b7401 100644
--- a/main/src/test/scala/sbt/internals/parser/EvaluateConfigurationsOriginal.scala
+++ b/main/src/test/scala/sbt/internals/parser/EvaluateConfigurationsOriginal.scala
@@ -2,7 +2,8 @@ package sbt.internals.parser
 
 import java.io.File
 
-import sbt.{ EvaluateConfigurations, LineRange }
+import sbt.EvaluateConfigurations
+import sbt.internal.util.LineRange
 
 import scala.annotation.tailrec
 
@@ -14,4 +15,4 @@ object EvaluateConfigurationsOriginal {
       EvaluateConfigurations.splitExpressions(lines)
     }
 
-}
\ No newline at end of file
+}
diff --git a/main/src/test/scala/sbt/internals/parser/SplitExpressions.scala b/main/src/test/scala/sbt/internals/parser/SplitExpressions.scala
index a93dde00d..3ef22988f 100644
--- a/main/src/test/scala/sbt/internals/parser/SplitExpressions.scala
+++ b/main/src/test/scala/sbt/internals/parser/SplitExpressions.scala
@@ -2,7 +2,7 @@ package sbt.internals.parser
 
 import java.io.File
 
-import sbt.LineRange
+import sbt.internal.util.LineRange
 
 object SplitExpressions {
   type SplitExpression = (File, Seq[String]) => (Seq[(String, Int)], Seq[(String, LineRange)])
diff --git a/main/src/test/scala/sbt/internals/parser/SplitExpressionsFilesTest.scala b/main/src/test/scala/sbt/internals/parser/SplitExpressionsFilesTest.scala
index 224bb3b74..9cbc909ca 100644
--- a/main/src/test/scala/sbt/internals/parser/SplitExpressionsFilesTest.scala
+++ b/main/src/test/scala/sbt/internals/parser/SplitExpressionsFilesTest.scala
@@ -9,6 +9,7 @@ import org.specs2.mutable.Specification
 import scala.annotation.tailrec
 import scala.io.Source
 import scala.tools.reflect.ToolBoxError
+import sbt.internal.util.LineRange
 
 class SplitExpressionsFilesTest extends AbstractSplitExpressionsFilesTest("/old-format/")
 
@@ -16,7 +17,7 @@ class SplitExpressionsFilesTest extends AbstractSplitExpressionsFilesTest("/old-
 
 abstract class AbstractSplitExpressionsFilesTest(pathName: String) extends Specification {
 
-  case class SplitterComparison(oldSplitterResult: util.Try[(Seq[(String, Int)], Seq[LineRange])], newSplitterResult: util.Try[(Seq[(String, Int)], Seq[LineRange])])
+  case class SplitterComparison(oldSplitterResult: scala.util.Try[(Seq[(String, Int)], Seq[LineRange])], newSplitterResult: scala.util.Try[(Seq[(String, Int)], Seq[LineRange])])
 
   val oldSplitter: SplitExpressions.SplitExpression = EvaluateConfigurationsOriginal.splitExpressions
   val newSplitter: SplitExpressions.SplitExpression = EvaluateConfigurations.splitExpressions
@@ -40,7 +41,7 @@ abstract class AbstractSplitExpressionsFilesTest(pathName: String) extends Speci
       printResults(results)
 
       val validResults = results.collect {
-        case (path, SplitterComparison(util.Success(oldRes), util.Success(newRes))) if oldRes == newRes => path
+        case (path, SplitterComparison(scala.util.Success(oldRes), scala.util.Success(newRes))) if oldRes == newRes => path
       }
 
       validResults.length must be_==(results.length)
@@ -112,19 +113,19 @@ abstract class AbstractSplitExpressionsFilesTest(pathName: String) extends Speci
     removeDoubleSlashReversed(statements.reverse, lineRange).map(t => (t._1.reverse, t._2))
   }
 
-  def splitLines(file: File, splitter: SplitExpressions.SplitExpression, lines: List[String]): util.Try[(Seq[(String, Int)], Seq[LineRange])] = {
+  def splitLines(file: File, splitter: SplitExpressions.SplitExpression, lines: List[String]): scala.util.Try[(Seq[(String, Int)], Seq[LineRange])] = {
     try {
       val (imports, settingsAndDefs) = splitter(file, lines)
 
       //TODO: Return actual contents (after making both splitter...
       //TODO: ...implementations return CharRanges instead of LineRanges)
       val settingsAndDefWithoutComments = settingsAndDefs.flatMap(t => removeCommentFromStatement(t._1, t._2))
-      util.Success((imports.map(imp => (imp._1.trim, imp._2)), settingsAndDefWithoutComments))
+      scala.util.Success((imports.map(imp => (imp._1.trim, imp._2)), settingsAndDefWithoutComments))
     } catch {
       case e: ToolBoxError =>
-        util.Failure(e)
+        scala.util.Failure(e)
       case e: Throwable =>
-        util.Failure(e)
+        scala.util.Failure(e)
     }
   }
 
@@ -132,12 +133,12 @@ abstract class AbstractSplitExpressionsFilesTest(pathName: String) extends Speci
     for ((file, comparison) <- results) {
       val fileName = file.getName
       comparison match {
-        case SplitterComparison(util.Failure(ex), _) =>
+        case SplitterComparison(scala.util.Failure(ex), _) =>
           println(s"In file: $fileName, old splitter failed. ${ex.toString}")
-        case SplitterComparison(_, util.Failure(ex)) =>
+        case SplitterComparison(_, scala.util.Failure(ex)) =>
           println(s"In file: $fileName, new splitter failed. ${ex.toString}")
           ex.printStackTrace()
-        case SplitterComparison(util.Success(resultOld), util.Success(resultNew)) =>
+        case SplitterComparison(scala.util.Success(resultOld), scala.util.Success(resultNew)) =>
           if (resultOld != resultNew) {
             println(
               s"""In file: $fileName, results differ:
@@ -150,4 +151,4 @@ abstract class AbstractSplitExpressionsFilesTest(pathName: String) extends Speci
 
     }
   }
-}
\ No newline at end of file
+}
diff --git a/run/src/main/scala/sbt/Fork.scala b/run/src/main/scala/sbt/Fork.scala
index 8272b8baf..27e574f03 100644
--- a/run/src/main/scala/sbt/Fork.scala
+++ b/run/src/main/scala/sbt/Fork.scala
@@ -6,6 +6,9 @@ package sbt
 import java.io.{ File, OutputStream }
 import java.util.Locale
 
+import sbt.util.Logger
+import scala.sys.process.{ Process, ProcessBuilder }
+
 @deprecated("Use ForkOptions", "0.13.0")
 trait ForkJava {
   def javaHome: Option[File]
@@ -102,7 +105,7 @@ sealed class Fork(val commandName: String, val runnerClass: Option[String]) {
         environment.put(Fork.ClasspathEnvKey, cpenv)
       outputStrategy.getOrElse(StdoutOutput) match {
         case StdoutOutput           => Process(builder).run(connectInput)
-        case BufferedOutput(logger) => Process(builder).runBuffered(logger, connectInput)
+        case BufferedOutput(logger) => logger.buffer { Process(builder).run(logger, connectInput) }
         case LoggedOutput(logger)   => Process(builder).run(logger, connectInput)
         case CustomOutput(output)   => (Process(builder) #> output).run(connectInput)
       }
@@ -188,7 +191,7 @@ object Fork {
           environment.put(key, value)
         outputStrategy match {
           case StdoutOutput           => Process(builder).run(connectInput)
-          case BufferedOutput(logger) => Process(builder).runBuffered(logger, connectInput)
+          case BufferedOutput(logger) => logger.buffer { Process(builder).run(logger, connectInput) }
           case LoggedOutput(logger)   => Process(builder).run(logger, connectInput)
           case CustomOutput(output)   => (Process(builder) #> output).run(connectInput)
         }
diff --git a/run/src/main/scala/sbt/Run.scala b/run/src/main/scala/sbt/Run.scala
index aff41f10f..86aa11278 100644
--- a/run/src/main/scala/sbt/Run.scala
+++ b/run/src/main/scala/sbt/Run.scala
@@ -9,6 +9,10 @@ import java.lang.reflect.{ Method, Modifier }
 import Modifier.{ isPublic, isStatic }
 import classpath.ClasspathUtilities
 
+import sbt.io.Path
+
+import sbt.util.Logger
+
 trait ScalaRun {
   def run(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Option[String]
 }
diff --git a/run/src/main/scala/sbt/TrapExit.scala b/run/src/main/scala/sbt/TrapExit.scala
index 8770f7739..8bbb4b526 100644
--- a/run/src/main/scala/sbt/TrapExit.scala
+++ b/run/src/main/scala/sbt/TrapExit.scala
@@ -18,6 +18,8 @@ import java.util.concurrent.{ ConcurrentHashMap => CMap }
 import java.lang.Integer.{ toHexString => hex }
 import java.lang.Long.{ toHexString => hexL }
 
+import sbt.util.Logger
+
 import TrapExit._
 
 /**
diff --git a/run/src/test/scala/sbt/ForkTest.scala b/run/src/test/scala/sbt/ForkTest.scala
index 08bc0ba51..01e726ec9 100644
--- a/run/src/test/scala/sbt/ForkTest.scala
+++ b/run/src/test/scala/sbt/ForkTest.scala
@@ -5,6 +5,9 @@ import Prop.{ Exception => _, _ }
 import Gen.{ alphaNumChar, frequency, nonEmptyListOf }
 import java.io.File
 
+import sbt.internal.util.TestLogger
+import sbt.io.{ IO, Path }
+
 object ForkTest extends Properties("Fork") {
   /**
    * Heuristic for limiting the length of the classpath string.
@@ -55,4 +58,11 @@ object ForkTest extends Properties("Fork") {
         cp
     } else
       cp
-}
\ No newline at end of file
+}
+
+// Object used in the tests
+object exit {
+  def main(args: Array[String]): Unit = {
+    System.exit(java.lang.Integer.parseInt(args(0)))
+  }
+}
diff --git a/sbt-maven-resolver/src/main/java/org/apache/maven/repository/internal/SbtArtifactDescriptorReader.java b/sbt-maven-resolver/src/main/java/org/apache/maven/repository/internal/SbtArtifactDescriptorReader.java
index 63a465cb7..b215ea720 100644
--- a/sbt-maven-resolver/src/main/java/org/apache/maven/repository/internal/SbtArtifactDescriptorReader.java
+++ b/sbt-maven-resolver/src/main/java/org/apache/maven/repository/internal/SbtArtifactDescriptorReader.java
@@ -81,8 +81,8 @@ import org.eclipse.aether.spi.log.Logger;
 import org.eclipse.aether.spi.log.LoggerFactory;
 import org.eclipse.aether.spi.log.NullLoggerFactory;
 import org.eclipse.aether.transfer.ArtifactNotFoundException;
-import sbt.mavenint.PomExtraDependencyAttributes;
-import sbt.mavenint.SbtPomExtraProperties;
+import sbt.internal.librarymanagement.mavenint.PomExtraDependencyAttributes;
+import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties;
 
 /**
  * A hacked version of maven's default artifact descriptor reader which we use in place of the standard aether adapter.
@@ -557,4 +557,4 @@ public class SbtArtifactDescriptorReader
     public void setVersionRangeResolver(final VersionRangeResolver versionRangeResolver) {
         this.versionRangeResolver = versionRangeResolver;
     }
-}
\ No newline at end of file
+}
diff --git a/sbt-maven-resolver/src/main/scala/sbt/MavenResolverConverter.scala b/sbt-maven-resolver/src/main/scala/sbt/MavenResolverConverter.scala
index 94274edc9..cb52c0980 100644
--- a/sbt-maven-resolver/src/main/scala/sbt/MavenResolverConverter.scala
+++ b/sbt-maven-resolver/src/main/scala/sbt/MavenResolverConverter.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.librarymanagement.{ MavenCache, MavenRepository, UpdateOptions }
+
 import UpdateOptions.ResolverConverter
 import sbt.mavenint.{ MavenCacheRepositoryResolver, MavenRemoteRepositoryResolver }
 
diff --git a/sbt-maven-resolver/src/main/scala/sbt/mavenint/FileTransport.scala b/sbt-maven-resolver/src/main/scala/sbt/mavenint/FileTransport.scala
index ad0c3b0ee..2966395e6 100644
--- a/sbt-maven-resolver/src/main/scala/sbt/mavenint/FileTransport.scala
+++ b/sbt-maven-resolver/src/main/scala/sbt/mavenint/FileTransport.scala
@@ -5,6 +5,8 @@ import org.apache.ivy.plugins.repository.url.URLResource
 import org.eclipse.aether.repository.RemoteRepository
 import org.eclipse.aether.spi.connector.transport._
 
+import sbt.io.IO
+
 /**
  * A bridge file transportation protocol which uses some Ivy/sbt mechanisms.
  */
@@ -25,17 +27,17 @@ class FileTransport(repository: RemoteRepository) extends AbstractTransporter {
   override def implGet(out: GetTask): Unit = {
     val from = toFile(out)
     if (!from.exists()) throw new NotFoundException(s"Could not find ${out.getLocation}")
-    sbt.IO.copyFile(from, out.getDataFile, true)
+    IO.copyFile(from, out.getDataFile, true)
   }
   override def implPut(put: PutTask): Unit = {
     val to = toFile(put)
     Option(put.getDataFile) match {
       case Some(from) =>
-        sbt.IO.copyFile(from, to, true)
+        IO.copyFile(from, to, true)
       case None =>
         // Here it's most likely a SHA or somethign where we read from memory.
         val in = put.newInputStream
-        try sbt.IO.transfer(in, to)
+        try IO.transfer(in, to)
         finally in.close()
     }
   }
diff --git a/sbt-maven-resolver/src/main/scala/sbt/mavenint/HttpTransport.scala b/sbt-maven-resolver/src/main/scala/sbt/mavenint/HttpTransport.scala
index 4ffda4185..21c0be482 100644
--- a/sbt-maven-resolver/src/main/scala/sbt/mavenint/HttpTransport.scala
+++ b/sbt-maven-resolver/src/main/scala/sbt/mavenint/HttpTransport.scala
@@ -30,9 +30,9 @@ class HttpTransport(repository: RemoteRepository) extends AbstractTransporter {
       case None =>
         // TODO - Ivy does not support uploading not from a file.  This isn't very efficient in ANY way,
         //        so if we rewrite the URL handler for Ivy we should fix this as well.
-        sbt.IO.withTemporaryFile("tmp", "upload") { file =>
+        sbt.io.IO.withTemporaryFile("tmp", "upload") { file =>
           val in = put.newInputStream()
-          try sbt.IO.transfer(in, file)
+          try sbt.io.IO.transfer(in, file)
           finally in.close()
           URLHandlerRegistry.getDefault.upload(file, to, null)
         }
diff --git a/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenCacheRepositoryResolver.scala b/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenCacheRepositoryResolver.scala
index b996f9172..feda8eb7e 100644
--- a/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenCacheRepositoryResolver.scala
+++ b/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenCacheRepositoryResolver.scala
@@ -13,10 +13,14 @@ import org.eclipse.aether.resolution.{
   VersionRequest => AetherVersionRequest,
   VersionRangeRequest => AetherVersionRangeRequest
 }
-import sbt.ivyint.CustomMavenResolver
+
+import sbt.internal.librarymanagement.ivyint.CustomMavenResolver
+import sbt.librarymanagement.MavenCache
 
 import scala.collection.JavaConverters._
 
+import sbt.io.IO
+
 /**
  * A resolver instance which can resolve from a maven CACHE.
  *
@@ -26,7 +30,7 @@ class MavenCacheRepositoryResolver(val repo: MavenCache, settings: IvySettings)
     extends MavenRepositoryResolver(settings) with CustomMavenResolver {
   setName(repo.name)
   protected val system = MavenRepositorySystemFactory.newRepositorySystemImpl
-  sbt.IO.createDirectory(repo.rootFile)
+  IO.createDirectory(repo.rootFile)
   protected val session = MavenRepositorySystemFactory.newSessionImpl(system, repo.rootFile)
   protected def setRepository(request: AetherMetadataRequest): AetherMetadataRequest = request
   protected def addRepositories(request: AetherDescriptorRequest): AetherDescriptorRequest = request
diff --git a/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenRemoteRepositoryResolver.scala b/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenRemoteRepositoryResolver.scala
index 067c2fa11..e50b1e905 100644
--- a/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenRemoteRepositoryResolver.scala
+++ b/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenRemoteRepositoryResolver.scala
@@ -15,7 +15,10 @@ import org.eclipse.aether.resolution.{
   VersionRequest => AetherVersionRequest,
   VersionRangeRequest => AetherVersionRangeRequest
 }
-import sbt.ivyint.CustomRemoteMavenResolver
+
+import sbt.internal.librarymanagement.ivyint.CustomRemoteMavenResolver
+import sbt.librarymanagement.MavenRepository
+
 import scala.collection.JavaConverters._
 
 /**
@@ -33,7 +36,7 @@ class MavenRemoteRepositoryResolver(val repo: MavenRepository, settings: IvySett
   //        We're not sure if we care whether or not this means that the wrong resolver may report finding an artifact.
   //        The key is not to duplicate files repeatedly across many caches.
   private val localRepo = new java.io.File(settings.getDefaultIvyUserDir, s"maven-cache")
-  sbt.IO.createDirectory(localRepo)
+  sbt.io.IO.createDirectory(localRepo)
   protected val session = MavenRepositorySystemFactory.newSessionImpl(system, localRepo)
   private val aetherRepository = {
     new org.eclipse.aether.repository.RemoteRepository.Builder(repo.name, SbtRepositoryLayout.LAYOUT_NAME, repo.root).build()
diff --git a/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenRepositoryResolver.scala b/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenRepositoryResolver.scala
index e550b9c0a..1c81936fa 100644
--- a/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenRepositoryResolver.scala
+++ b/sbt-maven-resolver/src/main/scala/sbt/mavenint/MavenRepositoryResolver.scala
@@ -30,9 +30,12 @@ import org.eclipse.aether.resolution.{
   VersionRangeRequest => AetherVersionRangeRequest
 }
 import org.eclipse.aether.{ RepositorySystem, RepositorySystemSession }
-import sbt.ivyint.{ CustomMavenResolver, CustomRemoteMavenResolver }
+
+import sbt.internal.librarymanagement.ivyint.{ CustomMavenResolver, CustomRemoteMavenResolver }
+import sbt.internal.librarymanagement.mavenint.{ PomExtraDependencyAttributes, SbtPomExtraProperties }
+import sbt.internal.librarymanagement.MakePom
+
 import sbt.mavenint.MavenRepositoryResolver.JarPackaging
-import sbt.{ MavenCache, MavenRepository }
 
 import scala.collection.JavaConverters._
 
@@ -116,9 +119,9 @@ abstract class MavenRepositoryResolver(settings: IvySettings) extends AbstractRe
     val context = IvyContext.pushNewCopyContext
     try {
       val drid: ModuleRevisionId =
-        if (sbt.MakePom.isDependencyVersionRange(dd.getDependencyRevisionId.getRevision)) {
+        if (MakePom.isDependencyVersionRange(dd.getDependencyRevisionId.getRevision)) {
           Message.debug(s"Got a dynamic revision, attempting to convert to real revision: ${dd.getDependencyRevisionId}")
-          val revision = sbt.MakePom.makeDependencyVersion(dd.getDependencyRevisionId.getRevision)
+          val revision = MakePom.makeDependencyVersion(dd.getDependencyRevisionId.getRevision)
           // TODO - Alter revision id to be maven-friendly first.
           val coords =
             s"${dd.getDependencyRevisionId.getOrganisation}:${aetherArtifactIdFromMrid(dd.getDependencyRevisionId)}:${revision}"
diff --git a/sbt-maven-resolver/src/main/scala/sbt/mavenint/SbtRepositoryLayout.scala b/sbt-maven-resolver/src/main/scala/sbt/mavenint/SbtRepositoryLayout.scala
index e15fecb1f..77d065cf1 100644
--- a/sbt-maven-resolver/src/main/scala/sbt/mavenint/SbtRepositoryLayout.scala
+++ b/sbt-maven-resolver/src/main/scala/sbt/mavenint/SbtRepositoryLayout.scala
@@ -10,6 +10,8 @@ import org.eclipse.aether.spi.connector.layout.RepositoryLayout.Checksum
 import org.eclipse.aether.spi.connector.layout.{ RepositoryLayout, RepositoryLayoutFactory }
 import org.eclipse.aether.transfer.NoRepositoryLayoutException
 
+import sbt.internal.librarymanagement.mavenint.SbtPomExtraProperties
+
 import scala.util.matching.Regex
 
 /** A factory which knows how to create repository layouts which can find sbt plugins. */
@@ -94,4 +96,4 @@ object SbtRepositoryLayout extends RepositoryLayout {
 
   private def getChecksums(location: URI): java.util.List[Checksum] =
     java.util.Arrays.asList(Checksum.forLocation(location, "SHA-1"), Checksum.forLocation(location, "MD5"))
-}
\ No newline at end of file
+}
diff --git a/sbt-maven-resolver/src/test/scala/MavenResolutionSpec.scala b/sbt-maven-resolver/src/test/scala/MavenResolutionSpec.scala
index 1262cf7d1..183ded0b3 100644
--- a/sbt-maven-resolver/src/test/scala/MavenResolutionSpec.scala
+++ b/sbt-maven-resolver/src/test/scala/MavenResolutionSpec.scala
@@ -1,30 +1,29 @@
 package sbt
 
 import java.io.FileInputStream
-import org.specs2._
-import sbt.mavenint.PomExtraDependencyAttributes
+
+import sbt.internal.librarymanagement.BaseIvySpecification
+import sbt.internal.librarymanagement.mavenint.PomExtraDependencyAttributes
+import sbt.librarymanagement.{ Artifact, Configurations, CrossVersion, DefaultMavenRepository, MavenRepository, ModuleID, Resolver, UpdateOptions }
+
+import sbt.internal.util.ShowLines
 
 class MavenResolutionSpec extends BaseIvySpecification {
-  def is = args(sequential = true) ^ s2""".stripMargin
 
-  This is a specification to check the maven resolution
+  "the maven resolution" should "handle sbt plugins" in resolveSbtPlugins
 
-  Resolving a maven dependency should
-     handle sbt plugins                                           $resolveSbtPlugins
-     use ivy for conflict resolution                              $resolveMajorConflicts
-     handle cross configuration deps                              $resolveCrossConfigurations
-     publish with maven-metadata                                  $publishMavenMetadata
-     resolve transitive maven dependencies                        $resolveTransitiveMavenDependency
-     resolve intransitive maven dependencies                      $resolveIntransitiveMavenDependency
-     handle transitive configuration shifts                       $resolveTransitiveConfigurationMavenDependency
-     resolve source and doc                                       $resolveSourceAndJavadoc
-     resolve nonstandard (jdk5) classifier                        $resolveNonstandardClassifier
-     Resolve pom artifact dependencies                            $resolvePomArtifactAndDependencies
-     Fail if JAR artifact is not found w/ POM                     $failIfMainArtifactMissing
-     Fail if POM.xml is not found                                 $failIfPomMissing
-     resolve publication date for -SNAPSHOT                       $resolveSnapshotPubDate
-
-                                                                """ // */
+  it should "use ivy for conflict resolution" in resolveMajorConflicts
+  it should "handle cross configuration deps" in resolveCrossConfigurations
+  it should "publish with maven-metadata" in publishMavenMetadata
+  it should "resolve transitive maven dependencies" in resolveTransitiveMavenDependency
+  it should "resolve intransitive maven dependencies" in resolveIntransitiveMavenDependency
+  it should "handle transitive configuration shifts" in resolveTransitiveConfigurationMavenDependency
+  it should "resolve source and doc" in resolveSourceAndJavadoc
+  it should "resolve nonstandard (jdk5) classifier" in resolveNonstandardClassifier
+  it should "Resolve pom artifact dependencies" in resolvePomArtifactAndDependencies
+  it should "Fail if JAR artifact is not found w/ POM" in failIfMainArtifactMissing
+  it should "Fail if POM.xml is not found" in failIfPomMissing
+  it should "resolve publication date for -SNAPSHOT" in resolveSnapshotPubDate
 
   // TODO - test latest.integration and .+
 
@@ -59,7 +58,7 @@ class MavenResolutionSpec extends BaseIvySpecification {
   def resolveMajorConflicts = {
     val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")),
       Seq(majorConflictLib), None, defaultUpdateOptions)
-    val report = ivyUpdate(m) // must not(throwAn[IllegalStateException])
+    val report = ivyUpdate(m) // should not(throwAn[IllegalStateException])
     val jars =
       for {
         conf <- report.configurations
@@ -69,7 +68,7 @@ class MavenResolutionSpec extends BaseIvySpecification {
         (a, f) <- m.artifacts
         if a.extension == "jar"
       } yield f
-    jars must haveSize(1)
+    jars should have size 1
   }
 
   def resolveCrossConfigurations = {
@@ -85,12 +84,12 @@ class MavenResolutionSpec extends BaseIvySpecification {
         (a, f) <- m.artifacts
         if a.extension == "jar"
       } yield f
-    jars must haveSize(1)
+    jars should have size 1
   }
 
   def resolveSbtPlugins = {
 
-    def sha(f: java.io.File): String = sbt.Hash.toHex(sbt.Hash(f))
+    def sha(f: java.io.File): String = sbt.io.Hash.toHex(sbt.io.Hash(f))
     def findSbtIdeaJars(dep: ModuleID, name: String) = {
       val m = module(ModuleID("com.example", name, "0.1.0", Some("compile")), Seq(dep), None, defaultUpdateOptions)
       val report = ivyUpdate(m)
@@ -108,7 +107,9 @@ class MavenResolutionSpec extends BaseIvySpecification {
     System.err.println(s"${oldJars.mkString("\n")}")
     val newJars = findSbtIdeaJars(sbtPlugin, "new")
     System.err.println(s"${newJars.mkString("\n")}")
-    (newJars must haveSize(1)) and (oldJars must haveSize(1)) and (oldJars.map(_._2) must not(containTheSameElementsAs(newJars.map(_._2))))
+    (newJars should have size 1)
+    (oldJars should have size 1)
+    (oldJars.map(_._2) should not(contain theSameElementsAs (newJars.map(_._2))))
   }
 
   def resolveSnapshotPubDate = {
@@ -122,7 +123,7 @@ class MavenResolutionSpec extends BaseIvySpecification {
         if m.module.revision endsWith "-SNAPSHOT"
         date <- m.publicationDate
       } yield date
-    (pubTime must haveSize(1))
+    (pubTime should have size 1)
   }
 
   def resolvePomArtifactAndDependencies = {
@@ -137,18 +138,18 @@ class MavenResolutionSpec extends BaseIvySpecification {
         (a, f) <- m.artifacts
         if a.extension == "jar"
       } yield f
-    jars must haveSize(2)
+    jars should have size 2
   }
 
   def failIfPomMissing = {
     // TODO - we need the jar to not exist too.
     val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(ModuleID("org.scala-sbt", "does-not-exist", "1.0", Some("compile"))), Some("2.10.2"), defaultUpdateOptions)
-    ivyUpdate(m) must throwAn[Exception]
+    an[Exception] should be thrownBy ivyUpdate(m)
   }
 
   def failIfMainArtifactMissing = {
     val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(jmxri), Some("2.10.2"), defaultUpdateOptions)
-    ivyUpdate(m) must throwAn[Exception]
+    an[Exception] should be thrownBy ivyUpdate(m)
   }
 
   def resolveNonstandardClassifier = {
@@ -163,9 +164,9 @@ class MavenResolutionSpec extends BaseIvySpecification {
         (a, f) <- m.artifacts
         if a.extension == "jar"
       } yield f
-    (report.configurations must haveSize(configurations.size)) and
-      (jars must haveSize(1))
-    (jars.forall(_.exists) must beTrue)
+    (report.configurations should have size configurations.size)
+    (jars should have size 1)
+    (jars.forall(_.exists) shouldBe true)
 
   }
 
@@ -181,9 +182,9 @@ class MavenResolutionSpec extends BaseIvySpecification {
         (a, f) <- m.artifacts
         if a.extension == "jar"
       } yield f
-    (report.configurations must haveSize(configurations.size)) and
-      (jars must not(beEmpty)) and
-      (jars.forall(_.exists) must beTrue)
+    (report.configurations should have size configurations.size)
+    (jars should not be empty)
+    (jars.forall(_.exists) shouldBe true)
 
   }
 
@@ -208,8 +209,9 @@ class MavenResolutionSpec extends BaseIvySpecification {
         (a, f) <- m.artifacts
         if a.extension == "jar"
       } yield f
-    (report.configurations must haveSize(configurations.size)) and
-      (transitiveJars must beEmpty) and (directJars.forall(_.exists) must beTrue)
+    (report.configurations should have size configurations.size)
+    (transitiveJars shouldBe empty)
+    (directJars.forall(_.exists) shouldBe true)
   }
 
   def resolveTransitiveConfigurationMavenDependency = {
@@ -224,9 +226,9 @@ class MavenResolutionSpec extends BaseIvySpecification {
         (a, f) <- m.artifacts
         if a.extension == "jar"
       } yield f
-    (report.configurations must haveSize(configurations.size)) and
-      (jars must not(beEmpty)) and
-      (jars.forall(_.exists) must beTrue)
+    (report.configurations should have size configurations.size)
+    (jars should not be empty)
+    (jars.forall(_.exists) shouldBe true)
 
   }
 
@@ -248,8 +250,8 @@ class MavenResolutionSpec extends BaseIvySpecification {
         (a, f) <- m.artifacts
         if (f.getName contains "sources") || (f.getName contains "javadoc")
       } yield f
-    (report.configurations must haveSize(configurations.size)) and
-      (jars must haveSize(2))
+    (report.configurations should have size configurations.size)
+    (jars should have size 2)
   }
 
   def publishMavenMetadata = {
@@ -259,9 +261,9 @@ class MavenResolutionSpec extends BaseIvySpecification {
       None,
       defaultUpdateOptions.withLatestSnapshots(true)
     )
-    sbt.IO.withTemporaryDirectory { dir =>
+    sbt.io.IO.withTemporaryDirectory { dir =>
       val pomFile = new java.io.File(dir, "pom.xml")
-      sbt.IO.write(pomFile,
+      sbt.io.IO.write(pomFile,
         """
           |<project>
           |   <groupId>com.example</groupId>
@@ -270,7 +272,7 @@ class MavenResolutionSpec extends BaseIvySpecification {
           |</project>
         """.stripMargin)
       val jarFile = new java.io.File(dir, "test-it-1.0-SNAPSHOT.jar")
-      sbt.IO.touch(jarFile)
+      sbt.io.IO.touch(jarFile)
       System.err.println(s"DEBUGME - Publishing $m to ${Resolver.publishMavenLocal}")
       ivyPublish(m, mkPublishConfiguration(
         Resolver.publishMavenLocal,
@@ -280,11 +282,11 @@ class MavenResolutionSpec extends BaseIvySpecification {
         )))
     }
     val baseLocalMavenDir: java.io.File = Resolver.publishMavenLocal.rootFile
-    val allFiles: Seq[java.io.File] = sbt.PathFinder(new java.io.File(baseLocalMavenDir, "com/example/test-it")).***.get
+    val allFiles: Seq[java.io.File] = sbt.io.PathFinder(new java.io.File(baseLocalMavenDir, "com/example/test-it")).allPaths.get
     val metadataFiles = allFiles.filter(_.getName contains "maven-metadata-local")
     // TODO - maybe we check INSIDE the metadata, or make sure we can get a publication date on resolve...
     // We end up with 4 files, two mavne-metadata files, and 2 maven-metadata-local files.
-    metadataFiles must haveSize(2)
+    metadataFiles should have size 2
   }
 
 }
diff --git a/sbt/src/main/scala/ProcessExtra.scala b/sbt/src/main/scala/ProcessExtra.scala
new file mode 100644
index 000000000..9a3c020c4
--- /dev/null
+++ b/sbt/src/main/scala/ProcessExtra.scala
@@ -0,0 +1,17 @@
+package sbt
+
+import java.lang.{ Process => JProcess, ProcessBuilder => JProcessBuilder }
+
+trait ProcessExtra {
+  import scala.sys.process._
+  import scala.sys.process.Process._
+  implicit def builderToProcess(builder: JProcessBuilder): ProcessBuilder = apply(builder)
+  implicit def fileToProcess(file: File): ProcessBuilder.FileBuilder = apply(file)
+  implicit def urlToProcess(url: URL): ProcessBuilder.URLBuilder = apply(url)
+  @deprecated("Use string interpolation", "0.13.0")
+  implicit def xmlToProcess(command: scala.xml.Elem): ProcessBuilder = apply(command)
+  implicit def buildersToProcess[T](builders: Seq[T])(implicit convert: T => ProcessBuilder.Source): Seq[ProcessBuilder.Source] = applySeq(builders)
+
+  implicit def stringToProcess(command: String): ProcessBuilder = apply(command)
+  implicit def stringSeqToProcess(command: Seq[String]): ProcessBuilder = apply(command)
+}
diff --git a/sbt/src/main/scala/package.scala b/sbt/src/main/scala/package.scala
index 0444c6c53..89e570a1d 100644
--- a/sbt/src/main/scala/package.scala
+++ b/sbt/src/main/scala/package.scala
@@ -1,8 +1,9 @@
 /* sbt -- Simple Build Tool
  * Copyright 2010, 2011 Mark Harrah
  */
-package object sbt extends sbt.std.TaskExtra with sbt.Types with sbt.ProcessExtra with sbt.impl.DependencyBuilders
-    with sbt.PathExtra with sbt.ProjectExtra with sbt.DependencyFilterExtra with sbt.BuildExtra with sbt.TaskMacroExtra
+package object sbt extends sbt.std.TaskExtra with sbt.internal.util.Types with sbt.ProcessExtra
+    with sbt.internal.librarymanagement.impl.DependencyBuilders with sbt.io.PathExtra with sbt.ProjectExtra
+    with sbt.internal.librarymanagement.DependencyFilterExtra with sbt.BuildExtra with sbt.TaskMacroExtra
     with sbt.ScopeFilter.Make {
   type Setting[T] = Def.Setting[T]
   type ScopedKey[T] = Def.ScopedKey[T]
@@ -27,7 +28,7 @@ package object sbt extends sbt.std.TaskExtra with sbt.Types with sbt.ProcessExtr
   final val ThisScope = Scope.ThisScope
   final val GlobalScope = Scope.GlobalScope
 
-  import sbt.{ Configurations => C }
+  import sbt.librarymanagement.{ Configuration, Configurations => C }
   final val Compile = C.Compile
   final val Test = C.Test
   final val Runtime = C.Runtime
@@ -39,7 +40,7 @@ package object sbt extends sbt.std.TaskExtra with sbt.Types with sbt.ProcessExtr
   // java.lang.System is more important, so don't alias this one
   //	final val System = C.System
   final val Optional = C.Optional
-  def config(s: String): Configuration = Configurations.config(s)
+  def config(s: String): Configuration = C.config(s)
 
   import language.experimental.macros
   def settingKey[T](description: String): SettingKey[T] = macro std.KeyMacro.settingKeyImpl[T]
diff --git a/scripted/base/src/main/scala/xsbt/test/FileCommands.scala b/scripted/base/src/main/scala/xsbt/test/FileCommands.scala
index 693cb9a7e..aef820626 100644
--- a/scripted/base/src/main/scala/xsbt/test/FileCommands.scala
+++ b/scripted/base/src/main/scala/xsbt/test/FileCommands.scala
@@ -3,8 +3,9 @@
  */
 package xsbt.test
 
+import scala.sys.process.Process
 import java.io.File
-import sbt.{ IO, Path }
+import sbt.io.{ IO, Path }
 import Path._
 
 class FileCommands(baseDirectory: File) extends BasicStatementHandler {
@@ -73,7 +74,7 @@ class FileCommands(baseDirectory: File) extends BasicStatementHandler {
     if (command.trim.isEmpty)
       scriptError("Command was empty.")
     else {
-      val exitValue = sbt.Process(command :: args, baseDirectory) !;
+      val exitValue = Process(command :: args, baseDirectory) !;
       if (exitValue != 0)
         sys.error("Nonzero exit value (" + exitValue + ")")
     }
diff --git a/scripted/base/src/main/scala/xsbt/test/TestScriptParser.scala b/scripted/base/src/main/scala/xsbt/test/TestScriptParser.scala
index 04af324ba..1c2d3b97d 100644
--- a/scripted/base/src/main/scala/xsbt/test/TestScriptParser.scala
+++ b/scripted/base/src/main/scala/xsbt/test/TestScriptParser.scala
@@ -7,7 +7,7 @@ import java.io.{ BufferedReader, File, InputStreamReader }
 import scala.util.parsing.combinator._
 import scala.util.parsing.input.Positional
 import Character.isWhitespace
-import sbt.IO
+import sbt.io.IO
 
 /*
 statement*
@@ -78,4 +78,4 @@ class TestScriptParser(handlers: Map[Char, StatementHandler]) extends RegexParse
     ((newline | err("expected start character " + handlers.keys.mkString("(", "", ")"))) ~> failure("end of input"))
 
   def newline = """\s*([\n\r]|$)""".r
-}
\ No newline at end of file
+}
diff --git a/scripted/base/src/test/scala/xsbt/test/FileCommandsSpec.scala b/scripted/base/src/test/scala/xsbt/test/FileCommandsSpec.scala
index bfaeec1d7..34a329675 100644
--- a/scripted/base/src/test/scala/xsbt/test/FileCommandsSpec.scala
+++ b/scripted/base/src/test/scala/xsbt/test/FileCommandsSpec.scala
@@ -4,7 +4,8 @@ import java.io.File
 import org.specs2.mutable.Specification
 import org.specs2.matcher.FileMatchers
 import sbt._
-import sbt.Path._
+import sbt.io.IO
+import sbt.io.Path._
 
 object FileCommandsSpec extends Specification with FileMatchers {
 
diff --git a/scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala b/scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala
index 5d7a776e7..f2a1b4c49 100644
--- a/scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala
+++ b/scripted/plugin/src/main/scala/sbt/ScriptedPlugin.scala
@@ -5,11 +5,15 @@ package sbt
 
 import Def.Initialize
 import Keys._
-import complete.{ Parser, DefaultParsers }
+import sbt.internal.util.complete.{ Parser, DefaultParsers }
 import classpath.ClasspathUtilities
 import java.lang.reflect.{ InvocationTargetException, Method }
 import java.util.Properties
 
+import sbt.librarymanagement.Configuration
+
+import sbt.io.{ AllPassFilter, PathFinder }
+
 object ScriptedPlugin extends Plugin {
   def scriptedConf = config("scripted-sbt") hide
   def scriptedLaunchConf = config("scripted-sbt-launch") hide
diff --git a/scripted/sbt/src/main/scala/sbt/test/SbtHandler.scala b/scripted/sbt/src/main/scala/sbt/test/SbtHandler.scala
index f38d19689..b11eea62a 100644
--- a/scripted/sbt/src/main/scala/sbt/test/SbtHandler.scala
+++ b/scripted/sbt/src/main/scala/sbt/test/SbtHandler.scala
@@ -8,7 +8,10 @@ import java.io.{ File, IOException }
 import xsbt.IPC
 import xsbt.test.{ StatementHandler, TestFailed }
 
-import Logger._
+import sbt.util.Logger
+import sbt.util.Logger._
+
+import scala.sys.process.{ BasicIO, Process }
 
 final case class SbtInstance(process: Process, server: IPC.Server)
 
@@ -64,9 +67,10 @@ final class SbtHandler(directory: File, launcher: File, log: Logger, launchOpts:
       val launcherJar = launcher.getAbsolutePath
       val globalBase = "-Dsbt.global.base=" + (new File(directory, "global")).getAbsolutePath
       val args = "java" :: (launchOpts.toList ++ (globalBase :: "-jar" :: launcherJar :: ("<" + server.port) :: Nil))
-      val io = BasicIO(log, false).withInput(_.close())
+      val io = BasicIO(false, log).withInput(_.close())
       val p = Process(args, directory) run (io)
-      Spawn { p.exitValue(); server.close() }
+      val thread = new Thread() { override def run() = { p.exitValue(); server.close() } }
+      thread.start()
       try { receive("Remote sbt initialization failed", server) }
       catch { case e: java.net.SocketException => throw new TestFailed("Remote sbt initialization failed") }
       p
diff --git a/scripted/sbt/src/main/scala/sbt/test/ScriptedTests.scala b/scripted/sbt/src/main/scala/sbt/test/ScriptedTests.scala
index d2164dfd6..b10ed94d5 100644
--- a/scripted/sbt/src/main/scala/sbt/test/ScriptedTests.scala
+++ b/scripted/sbt/src/main/scala/sbt/test/ScriptedTests.scala
@@ -10,7 +10,12 @@ import java.nio.charset.Charset
 
 import xsbt.IPC
 import xsbt.test.{ CommentHandler, FileCommands, ScriptRunner, TestScriptParser }
-import IO.wrapNull
+import sbt.io.{ DirectoryFilter, GlobFilter, HiddenFileFilter, Path }
+import sbt.io.IO.wrapNull
+import sbt.internal.io.Resources
+
+import sbt.internal.util.{ BufferedLogger, ConsoleLogger, FullLogger }
+import sbt.util.{ AbstractLogger, Logger }
 
 final class ScriptedTests(resourceBaseDirectory: File, bufferLog: Boolean, launcher: File, launchOpts: Seq[String]) {
   import ScriptedTests._
diff --git a/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala b/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
index f4f7a7dfe..ab89e1772 100644
--- a/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
+++ b/tasks/src/main/scala/sbt/ConcurrentRestrictions.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.internal.util.AttributeKey
+
 /**
  * Describes restrictions on concurrent execution for a set of tasks.
  *
@@ -188,4 +190,4 @@ object ConcurrentRestrictions {
         def take(): R = jservice.take().get()
       }
     }
-}
\ No newline at end of file
+}
diff --git a/tasks/src/main/scala/sbt/Execute.scala b/tasks/src/main/scala/sbt/Execute.scala
index b2799ea8e..29660c8a8 100644
--- a/tasks/src/main/scala/sbt/Execute.scala
+++ b/tasks/src/main/scala/sbt/Execute.scala
@@ -3,8 +3,9 @@
  */
 package sbt
 
-import ErrorHandling.wideConvert
-import Types._
+import sbt.internal.util.ErrorHandling.wideConvert
+import sbt.internal.util.{ DelegatingPMap, PMap, RMap, IDSet, ~> }
+import sbt.internal.util.Types._
 import Execute._
 
 import scala.annotation.tailrec
diff --git a/tasks/src/main/scala/sbt/ExecuteProgress.scala b/tasks/src/main/scala/sbt/ExecuteProgress.scala
index d2aed172e..1610d986f 100644
--- a/tasks/src/main/scala/sbt/ExecuteProgress.scala
+++ b/tasks/src/main/scala/sbt/ExecuteProgress.scala
@@ -1,5 +1,7 @@
 package sbt
 
+import sbt.internal.util.RMap
+
 /**
  * Processes progress events during task execution.
  * All methods are called from the same thread except `started` and `finished`,
@@ -65,4 +67,4 @@ private[sbt] object ExecuteProgress {
     def completed[T](state: Unit, task: A[T], result: Result[T]) = ()
     def allCompleted(state: Unit, results: RMap[A, Result]) = ()
   }
-}
\ No newline at end of file
+}
diff --git a/tasks/src/main/scala/sbt/Incomplete.scala b/tasks/src/main/scala/sbt/Incomplete.scala
index ee95ec2e8..5f40193de 100644
--- a/tasks/src/main/scala/sbt/Incomplete.scala
+++ b/tasks/src/main/scala/sbt/Incomplete.scala
@@ -3,6 +3,7 @@
  */
 package sbt
 
+import sbt.internal.util.IDSet
 import Incomplete.{ Error, Value => IValue }
 
 /**
@@ -15,7 +16,7 @@ import Incomplete.{ Error, Value => IValue }
  * @param directCause the exception that caused `node` to not complete
  */
 final case class Incomplete(node: Option[AnyRef], tpe: IValue = Error, message: Option[String] = None, causes: Seq[Incomplete] = Nil, directCause: Option[Throwable] = None)
-    extends Exception(message.orNull, directCause.orNull) with UnprintableException {
+    extends Exception(message.orNull, directCause.orNull) with sbt.internal.util.UnprintableException {
   override def toString = "Incomplete(node=" + node + ", tpe=" + tpe + ", msg=" + message + ", causes=" + causes + ", directCause=" + directCause + ")"
 }
 
diff --git a/tasks/src/main/scala/sbt/Node.scala b/tasks/src/main/scala/sbt/Node.scala
index 1051de271..e24b3a1d9 100644
--- a/tasks/src/main/scala/sbt/Node.scala
+++ b/tasks/src/main/scala/sbt/Node.scala
@@ -3,7 +3,8 @@
  */
 package sbt
 
-import Types._
+import sbt.internal.util.AList
+import sbt.internal.util.Types._
 
 /**
  * Represents a task node in a format understood by the task evaluation engine Execute.
diff --git a/tasks/src/main/scala/sbt/Result.scala b/tasks/src/main/scala/sbt/Result.scala
index 7456c76d1..62b2f1fa1 100644
--- a/tasks/src/main/scala/sbt/Result.scala
+++ b/tasks/src/main/scala/sbt/Result.scala
@@ -3,6 +3,8 @@
  */
 package sbt
 
+import sbt.internal.util.~>
+
 // used instead of Either[Incomplete, T] for type inference
 
 /** Result of completely evaluating a task.*/
@@ -36,4 +38,4 @@ object Result {
     case Left(i)  => Inc(i)
     case Right(v) => Value(v)
   }
-}
\ No newline at end of file
+}
diff --git a/tasks/standard/src/main/scala/sbt/Action.scala b/tasks/standard/src/main/scala/sbt/Action.scala
index e55ee21e9..b46b864b5 100644
--- a/tasks/standard/src/main/scala/sbt/Action.scala
+++ b/tasks/standard/src/main/scala/sbt/Action.scala
@@ -3,7 +3,8 @@
  */
 package sbt
 
-import Types._
+import sbt.internal.util.Types._
+import sbt.internal.util.{ ~>, AList, AttributeKey, AttributeMap }
 import Task._
 import ConcurrentRestrictions.{ Tag, TagMap, tagsKey }
 
@@ -79,4 +80,4 @@ final case class Info[T](attributes: AttributeMap = AttributeMap.empty, post: T
 object Info {
   val Name = AttributeKey[String]("name")
   val Description = AttributeKey[String]("description")
-}
\ No newline at end of file
+}
diff --git a/tasks/standard/src/main/scala/sbt/std/Streams.scala b/tasks/standard/src/main/scala/sbt/std/Streams.scala
index d3f98ee44..17fd19677 100644
--- a/tasks/standard/src/main/scala/sbt/std/Streams.scala
+++ b/tasks/standard/src/main/scala/sbt/std/Streams.scala
@@ -8,7 +8,11 @@ import java.io.{ InputStream, IOException, OutputStream, Reader, Writer }
 import java.io.{ BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter, PrintWriter }
 import java.io.{ Closeable, File, FileInputStream, FileOutputStream, InputStreamReader, OutputStreamWriter }
 
-import Path._
+import sbt.internal.io.DeferredWriter
+import sbt.io.IO
+import sbt.io.Path._
+
+import sbt.util.Logger
 
 // no longer specific to Tasks, so 'TaskStreams' should be renamed
 /**
diff --git a/tasks/standard/src/main/scala/sbt/std/System.scala b/tasks/standard/src/main/scala/sbt/std/System.scala
index 65d93d30d..9c4ba5c2e 100644
--- a/tasks/standard/src/main/scala/sbt/std/System.scala
+++ b/tasks/standard/src/main/scala/sbt/std/System.scala
@@ -4,7 +4,8 @@
 package sbt
 package std
 
-import Types._
+import sbt.internal.util.Types._
+import sbt.internal.util.{ ~>, AList, DelegatingPMap, RMap }
 import Task._
 import TaskExtra.{ all, existToAny }
 import Execute._
diff --git a/tasks/standard/src/main/scala/sbt/std/TaskExtra.scala b/tasks/standard/src/main/scala/sbt/std/TaskExtra.scala
index 10914daee..0d6085dfc 100644
--- a/tasks/standard/src/main/scala/sbt/std/TaskExtra.scala
+++ b/tasks/standard/src/main/scala/sbt/std/TaskExtra.scala
@@ -4,9 +4,13 @@
 package sbt
 package std
 
-import Types._
+import scala.sys.process.{ BasicIO, ProcessIO, ProcessBuilder }
+
+import sbt.internal.util.AList
+import sbt.internal.util.Types._
 import Task._
 import java.io.{ BufferedInputStream, BufferedReader, File, InputStream }
+import sbt.io.IO
 
 sealed trait MultiInTask[K[L[x]]] {
   def flatMap[T](f: K[Id] => Task[T]): Task[T]
@@ -184,7 +188,7 @@ object TaskExtra extends TaskExtra {
   def processIO(s: TaskStreams[_]): ProcessIO =
     {
       def transfer(id: String) = (in: InputStream) => BasicIO.transferFully(in, s.binary(id))
-      new ProcessIO(BasicIO.closeOut, transfer(s.outID), transfer(s.errorID), inheritInput = { _ => false })
+      new ProcessIO(_.close(), transfer(s.outID), transfer(s.errorID))
     }
   def reduced[S](i: IndexedSeq[Task[S]], f: (S, S) => S): Task[S] =
     i match {
diff --git a/tasks/standard/src/test/scala/TaskSerial.scala b/tasks/standard/src/test/scala/TaskSerial.scala
index b17855a4f..3480ec8b3 100644
--- a/tasks/standard/src/test/scala/TaskSerial.scala
+++ b/tasks/standard/src/test/scala/TaskSerial.scala
@@ -1,7 +1,7 @@
 package sbt
 package std
 
-import Types._
+import sbt.internal.util.Types._
 import TaskExtra._
 import TaskTest.tryRun
 import TaskGen.{ MaxWorkers, MaxWorkersGen }
@@ -77,4 +77,4 @@ object TaskTest {
       case Value(v) => v
       case Inc(i)   => throw i
     }
-}
\ No newline at end of file
+}
diff --git a/tasks/standard/src/test/scala/Test.scala b/tasks/standard/src/test/scala/Test.scala
index d92734c56..48e9d7c63 100644
--- a/tasks/standard/src/test/scala/Test.scala
+++ b/tasks/standard/src/test/scala/Test.scala
@@ -3,7 +3,8 @@
  */
 package sbt
 
-import Types._
+import sbt.internal.util.Types._
+import sbt.internal.util.AList
 import Task._
 import Execute._
 
diff --git a/tasks/standard/src/test/scala/TestRunnerSort.scala b/tasks/standard/src/test/scala/TestRunnerSort.scala
index a856ed86c..b7458b395 100644
--- a/tasks/standard/src/test/scala/TestRunnerSort.scala
+++ b/tasks/standard/src/test/scala/TestRunnerSort.scala
@@ -7,7 +7,7 @@ import org.scalacheck._
 import Prop._
 import TaskGen._
 import Task._
-import Types._
+import sbt.internal.util.Types._
 
 object TaskRunnerSortTest extends Properties("TaskRunnerSort") {
   property("sort") = forAll(TaskListGen, MaxWorkersGen) { (list: List[Int], workers: Int) =>
@@ -44,4 +44,4 @@ object TaskRunnerSortTest extends Properties("TaskRunnerSort") {
         }
       }
     }
-}
\ No newline at end of file
+}
diff --git a/testing/src/main/scala/sbt/TestFramework.scala b/testing/src/main/scala/sbt/TestFramework.scala
index a3813ab9c..a88e69a1b 100644
--- a/testing/src/main/scala/sbt/TestFramework.scala
+++ b/testing/src/main/scala/sbt/TestFramework.scala
@@ -9,6 +9,8 @@ import testing.{ Logger => TLogger, Task => TestTask, _ }
 import org.scalatools.testing.{ Framework => OldFramework }
 import classpath.{ ClasspathUtilities, DualLoader, FilteredLoader }
 import scala.annotation.tailrec
+import sbt.util.Logger
+import sbt.io.IO
 
 object TestResult extends Enumeration {
   val Passed, Failed, Error = Value
diff --git a/testing/src/main/scala/sbt/TestReportListener.scala b/testing/src/main/scala/sbt/TestReportListener.scala
index 53a015803..2e1f517a6 100644
--- a/testing/src/main/scala/sbt/TestReportListener.scala
+++ b/testing/src/main/scala/sbt/TestReportListener.scala
@@ -5,6 +5,8 @@
 package sbt
 
 import testing.{ Logger => TLogger, Event => TEvent, Status => TStatus }
+import sbt.internal.util.{ BufferedLogger, FullLogger }
+import sbt.util.{ Level, Logger }
 
 trait TestReportListener {
   /** called for each class or equivalent grouping */
@@ -78,20 +80,20 @@ object TestEvent {
 
 object TestLogger {
   @deprecated("Doesn't provide for underlying resources to be released.", "0.13.1")
-  def apply(logger: sbt.Logger, logTest: TestDefinition => sbt.Logger, buffered: Boolean): TestLogger =
+  def apply(logger: sbt.util.Logger, logTest: TestDefinition => sbt.util.Logger, buffered: Boolean): TestLogger =
     new TestLogger(new TestLogging(wrap(logger), tdef => contentLogger(logTest(tdef), buffered)))
 
   @deprecated("Doesn't provide for underlying resources to be released.", "0.13.1")
-  def contentLogger(log: sbt.Logger, buffered: Boolean): ContentLogger =
+  def contentLogger(log: sbt.util.Logger, buffered: Boolean): ContentLogger =
     {
       val blog = new BufferedLogger(FullLogger(log))
       if (buffered) blog.record()
       new ContentLogger(wrap(blog), () => blog.stopQuietly())
     }
 
-  final class PerTest private[sbt] (val log: sbt.Logger, val flush: () => Unit, val buffered: Boolean)
+  final class PerTest private[sbt] (val log: sbt.util.Logger, val flush: () => Unit, val buffered: Boolean)
 
-  def make(global: sbt.Logger, perTest: TestDefinition => PerTest): TestLogger =
+  def make(global: sbt.util.Logger, perTest: TestDefinition => PerTest): TestLogger =
     {
       def makePerTest(tdef: TestDefinition): ContentLogger =
         {
@@ -104,7 +106,7 @@ object TestLogger {
       new TestLogger(config)
     }
 
-  def wrap(logger: sbt.Logger): TLogger =
+  def wrap(logger: sbt.util.Logger): TLogger =
     new TLogger {
       def error(s: String) = log(Level.Error, s)
       def warn(s: String) = log(Level.Warn, s)
diff --git a/testing/src/main/scala/sbt/TestStatusReporter.scala b/testing/src/main/scala/sbt/TestStatusReporter.scala
index e74b69fc9..45f267035 100644
--- a/testing/src/main/scala/sbt/TestStatusReporter.scala
+++ b/testing/src/main/scala/sbt/TestStatusReporter.scala
@@ -4,6 +4,7 @@
 package sbt
 
 import java.io.File
+import sbt.io.IO
 
 import scala.collection.mutable.Map